repo_name
stringlengths 4
116
| path
stringlengths 3
942
| size
stringlengths 1
7
| content
stringlengths 3
1.05M
| license
stringclasses 15
values |
|---|---|---|---|---|
radzikowski/alf | vendor/symfony/src/Symfony/Component/Validator/Constraints/Url.php | 579 | <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Constraints;
class Url extends \Symfony\Component\Validator\Constraint
{
public $message = 'This value is not a valid URL';
public $protocols = array('http', 'https');
/**
* {@inheritDoc}
*/
public function getTargets()
{
return self::PROPERTY_CONSTRAINT;
}
} | mit |
MetSystem/msbuild | src/XMakeTasks/Csc.cs | 41306 | // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Text;
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using Microsoft.Build.Shared.LanguageParser;
using Microsoft.Build.Tasks.Hosting;
using Microsoft.Build.Tasks.InteropUtilities;
using Microsoft.Build.Utilities;
#if (!STANDALONEBUILD)
using Microsoft.Internal.Performance;
#endif
namespace Microsoft.Build.Tasks
{
/// <summary>
/// This class defines the "Csc" XMake task, which enables building assemblies from C#
/// source files by invoking the C# compiler. This is the new Roslyn XMake task,
/// meaning that the code is compiled by using the Roslyn compiler server, rather
/// than csc.exe. The two should be functionally identical, but the compiler server
/// should be significantly faster with larger projects and have a smaller memory
/// footprint.
/// </summary>
public class Csc : ManagedCompiler
{
private bool _useHostCompilerIfAvailable = false;
#region Properties
// Please keep these alphabetized. These are the parameters specific to Csc. The
// ones shared between Vbc and Csc are defined in ManagedCompiler.cs, which is
// the base class.
public bool AllowUnsafeBlocks
{
set { Bag["AllowUnsafeBlocks"] = value; }
get { return GetBoolParameterWithDefault("AllowUnsafeBlocks", false); }
}
public string ApplicationConfiguration
{
set { Bag["ApplicationConfiguration"] = value; }
get { return (string)Bag["ApplicationConfiguration"]; }
}
public string BaseAddress
{
set { Bag["BaseAddress"] = value; }
get { return (string)Bag["BaseAddress"]; }
}
public bool CheckForOverflowUnderflow
{
set { Bag["CheckForOverflowUnderflow"] = value; }
get { return GetBoolParameterWithDefault("CheckForOverflowUnderflow", false); }
}
public string DocumentationFile
{
set { Bag["DocumentationFile"] = value; }
get { return (string)Bag["DocumentationFile"]; }
}
public string DisabledWarnings
{
set { Bag["DisabledWarnings"] = value; }
get { return (string)Bag["DisabledWarnings"]; }
}
public bool ErrorEndLocation
{
set { Bag["ErrorEndLocation"] = value; }
get { return GetBoolParameterWithDefault("ErrorEndLocation", false); }
}
public string ErrorReport
{
set { Bag["ErrorReport"] = value; }
get { return (string)Bag["ErrorReport"]; }
}
public bool GenerateFullPaths
{
set { Bag["GenerateFullPaths"] = value; }
get { return GetBoolParameterWithDefault("GenerateFullPaths", false); }
}
public string LangVersion
{
set { Bag["LangVersion"] = value; }
get { return (string)Bag["LangVersion"]; }
}
public string ModuleAssemblyName
{
set { Bag["ModuleAssemblyName"] = value; }
get { return (string)Bag["ModuleAssemblyName"]; }
}
public bool NoStandardLib
{
set { Bag["NoStandardLib"] = value; }
get { return GetBoolParameterWithDefault("NoStandardLib", false); }
}
public string PdbFile
{
set { Bag["PdbFile"] = value; }
get { return (string)Bag["PdbFile"]; }
}
/// <summary>
/// Name of the language passed to "/preferreduilang" compiler option.
/// </summary>
/// <remarks>
/// If set to null, "/preferreduilang" option is omitted, and csc.exe uses its default setting.
/// Otherwise, the value is passed to "/preferreduilang" as is.
/// </remarks>
public string PreferredUILang
{
set { Bag["PreferredUILang"] = value; }
get { return (string)Bag["PreferredUILang"]; }
}
public string VsSessionGuid
{
set { Bag["VsSessionGuid"] = value; }
get { return (string)Bag["VsSessionGuid"]; }
}
public bool UseHostCompilerIfAvailable
{
set { _useHostCompilerIfAvailable = value; }
get { return _useHostCompilerIfAvailable; }
}
public int WarningLevel
{
set { Bag["WarningLevel"] = value; }
get { return GetIntParameterWithDefault("WarningLevel", 4); }
}
public string WarningsAsErrors
{
set { Bag["WarningsAsErrors"] = value; }
get { return (string)Bag["WarningsAsErrors"]; }
}
public string WarningsNotAsErrors
{
set { Bag["WarningsNotAsErrors"] = value; }
get { return (string)Bag["WarningsNotAsErrors"]; }
}
#endregion
#region Tool Members
/// <summary>
/// Return the name of the tool to execute.
/// </summary>
override protected string ToolName
{
get
{
return "csc2.exe";
}
}
/// <summary>
/// Return the path to the tool to execute.
/// </summary>
override protected string GenerateFullPathToTool()
{
string pathToTool = ToolLocationHelper.GetPathToBuildToolsFile(ToolName, ToolLocationHelper.CurrentToolsVersion);
if (null == pathToTool)
{
pathToTool = ToolLocationHelper.GetPathToDotNetFrameworkFile(ToolName, TargetDotNetFrameworkVersion.VersionLatest);
if (null == pathToTool)
{
Log.LogErrorWithCodeFromResources("General.FrameworksFileNotFound", ToolName, ToolLocationHelper.GetDotNetFrameworkVersionFolderPrefix(TargetDotNetFrameworkVersion.VersionLatest));
}
}
return pathToTool;
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
override protected internal void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/lib:", this.AdditionalLibPaths, ",");
commandLine.AppendPlusOrMinusSwitch("/unsafe", this.Bag, "AllowUnsafeBlocks");
commandLine.AppendPlusOrMinusSwitch("/checked", this.Bag, "CheckForOverflowUnderflow");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", ';', ',');
commandLine.AppendWhenTrue("/fullpaths", this.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendSwitchIfNotNull("/pdb:", this.PdbFile);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", this.Bag, "NoStandardLib");
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchWithInteger("/warn:", this.Bag, "WarningLevel");
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", this.GetDefineConstantsSwitch(this.DefineConstants));
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/appconfig:", this.ApplicationConfiguration);
commandLine.AppendWhenTrue("/errorendlocation", this.Bag, "ErrorEndLocation");
commandLine.AppendSwitchIfNotNull("/preferreduilang:", this.PreferredUILang);
commandLine.AppendPlusOrMinusSwitch("/highentropyva", this.Bag, "HighEntropyVA");
// If not design time build and the globalSessionGuid property was set then add a -globalsessionguid:<guid>
bool designTime = false;
if (this.HostObject != null)
{
var csHost = this.HostObject as ICscHostObject;
designTime = csHost.IsDesignTime();
}
if (!designTime)
{
if (!string.IsNullOrWhiteSpace(this.VsSessionGuid))
{
commandLine.AppendSwitchIfNotNull("/sqmsessionguid:", this.VsSessionGuid);
}
}
this.AddReferencesToCommandLine(commandLine);
base.AddResponseFileCommands(commandLine);
// This should come after the "TreatWarningsAsErrors" flag is processed (in managedcompiler.cs).
// Because if TreatWarningsAsErrors=false, then we'll have a /warnaserror- on the command-line,
// and then any specific warnings that should be treated as errors should be specified with
// /warnaserror+:<list> after the /warnaserror- switch. The order of the switches on the command-line
// does matter.
//
// Note that
// /warnaserror+
// is just shorthand for:
// /warnaserror+:<all possible warnings>
//
// Similarly,
// /warnaserror-
// is just shorthand for:
// /warnaserror-:<all possible warnings>
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", ';', ',');
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", ';', ',');
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective.
if (this.ResponseFiles != null)
{
foreach (ITaskItem response in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", response.ItemSpec);
}
}
}
#endregion
/// <summary>
/// The C# compiler (starting with Whidbey) supports assembly aliasing for references.
/// See spec at http://devdiv/spectool/Documents/Whidbey/VCSharp/Design%20Time/M3%20DCRs/DCR%20Assembly%20aliases.doc.
/// This method handles the necessary work of looking at the "Aliases" attribute on
/// the incoming "References" items, and making sure to generate the correct
/// command-line on csc.exe. The syntax for aliasing a reference is:
/// csc.exe /reference:Foo=System.Xml.dll
///
/// The "Aliases" attribute on the "References" items is actually a comma-separated
/// list of aliases, and if any of the aliases specified is the string "global",
/// then we add that reference to the command-line without an alias.
/// </summary>
/// <param name="commandLine"></param>
private void AddReferencesToCommandLine
(
CommandLineBuilderExtension commandLine
)
{
// If there were no references passed in, don't add any /reference: switches
// on the command-line.
if ((this.References == null) || (this.References.Length == 0))
{
return;
}
// Loop through all the references passed in. We'll be adding separate
// /reference: switches for each reference, and in some cases even multiple
// /reference: switches per reference.
foreach (ITaskItem reference in this.References)
{
// See if there was an "Alias" attribute on the reference.
string aliasString = reference.GetMetadata(ItemMetadataNames.aliases);
string switchName = "/reference:";
bool embed = MetadataConversionUtilities.TryConvertItemMetadataToBool
(
reference,
ItemMetadataNames.embedInteropTypes
);
if (embed == true)
{
switchName = "/link:";
}
if ((aliasString == null) || (aliasString.Length == 0))
{
// If there was no "Alias" attribute, just add this as a global reference.
commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);
}
else
{
// If there was an "Alias" attribute, it contains a comma-separated list
// of aliases to use for this reference. For each one of those aliases,
// we're going to add a separate /reference: switch to the csc.exe
// command-line
string[] aliases = aliasString.Split(',');
foreach (string alias in aliases)
{
// Trim whitespace.
string trimmedAlias = alias.Trim();
if (alias.Length == 0)
{
continue;
}
// The alias should be a valid C# identifier. Therefore it cannot
// contain comma, space, semicolon, or double-quote. Let's check for
// the existence of those characters right here, and bail immediately
// if any are present. There are a whole bunch of other characters
// that are not allowed in a C# identifier, but we'll just let csc.exe
// error out on those. The ones we're checking for here are the ones
// that could seriously interfere with the command-line parsing or could
// allow parameter injection.
if (trimmedAlias.IndexOfAny(new char[] { ',', ' ', ';', '"' }) != -1)
{
ErrorUtilities.VerifyThrowArgument
(
false,
"Csc.AssemblyAliasContainsIllegalCharacters",
reference.ItemSpec,
trimmedAlias
);
}
// The alias called "global" is special. It means that we don't
// give it an alias on the command-line.
if (String.Compare("global", trimmedAlias, StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);
}
else
{
// We have a valid (and explicit) alias for this reference. Add
// it to the command-line using the syntax:
// /reference:Foo=System.Xml.dll
commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec);
}
}
}
}
}
/// <summary>
/// Determines whether a particular string is a valid C# identifier. Legal
/// identifiers must start with a letter, and all the characters must be
/// letters or numbers. Underscore is considered a letter.
/// </summary>
private static bool IsLegalIdentifier
(
string identifier
)
{
// Must be non-empty.
if (identifier.Length == 0)
{
return false;
}
// First character must be a letter.
// From 2.4.2 of the C# Language Specification
// identifier-start-letter-character:
if (
!TokenChar.IsLetter(identifier[0]) &&
(identifier[0] != '_')
)
{
return false;
}
// All the other characters must be letters or numbers.
// From 2.4.2 of the C# Language Specification
// identifier-part-letter-character:
for (int i = 1; i < identifier.Length; i++)
{
char currentChar = identifier[i];
if (
!TokenChar.IsLetter(currentChar) &&
!TokenChar.IsDecimalDigit(currentChar) &&
!TokenChar.IsConnecting(currentChar) &&
!TokenChar.IsCombining(currentChar) &&
!TokenChar.IsFormatting(currentChar)
)
{
return false;
}
}
return true;
}
/// <summary>
/// Old VS projects had some pretty messed-up looking values for the
/// "DefineConstants" property. It worked fine in the IDE, because it
/// effectively munged up the string so that it ended up being valid for
/// the compiler. We do the equivalent munging here now.
///
/// Basically, we take the incoming string, and split it on comma/semicolon/space.
/// Then we look at the resulting list of strings, and remove any that are
/// illegal identifiers, and pass the remaining ones through to the compiler.
///
/// Note that CSharp does support assigning a value to the constants ... in
/// other words, a constant is either defined or not defined ... it can't have
/// an actual value.
/// </summary>
internal string GetDefineConstantsSwitch
(
string originalDefineConstants
)
{
if (originalDefineConstants == null)
{
return null;
}
StringBuilder finalDefineConstants = new StringBuilder();
// Split the incoming string on comma/semicolon/space.
string[] allIdentifiers = originalDefineConstants.Split(new char[] { ',', ';', ' ' });
// Loop through all the parts, and for the ones that are legal C# identifiers,
// add them to the outgoing string.
foreach (string singleIdentifier in allIdentifiers)
{
if (Csc.IsLegalIdentifier(singleIdentifier))
{
// Separate them with a semicolon if there's something already in
// the outgoing string.
if (finalDefineConstants.Length > 0)
{
finalDefineConstants.Append(";");
}
finalDefineConstants.Append(singleIdentifier);
}
else if (singleIdentifier.Length > 0)
{
Log.LogWarningWithCodeFromResources("Csc.InvalidParameterWarning", "/define:", singleIdentifier);
}
}
if (finalDefineConstants.Length > 0)
{
return finalDefineConstants.ToString();
}
else
{
// We wouldn't want to pass in an empty /define: switch on the csc.exe command-line.
return null;
}
}
/// <summary>
/// This method will initialize the host compiler object with all the switches,
/// parameters, resources, references, sources, etc.
///
/// It returns true if everything went according to plan. It returns false if the
/// host compiler had a problem with one of the parameters that was passed in.
///
/// This method also sets the "this.HostCompilerSupportsAllParameters" property
/// accordingly.
///
/// Example:
/// If we attempted to pass in WarningLevel="9876", then this method would
/// set HostCompilerSupportsAllParameters=true, but it would give a
/// return value of "false". This is because the host compiler fully supports
/// the WarningLevel parameter, but 9876 happens to be an illegal value.
///
/// Example:
/// If we attempted to pass in NoConfig=false, then this method would set
/// HostCompilerSupportsAllParameters=false, because while this is a legal
/// thing for csc.exe, the IDE compiler cannot support it. In this situation
/// the return value will also be false.
/// </summary>
private bool InitializeHostCompiler
(
// NOTE: For compat reasons this must remain ICscHostObject
// we can dynamically test for smarter interfaces later..
ICscHostObject cscHostObject
)
{
bool success;
this.HostCompilerSupportsAllParameters = this.UseHostCompilerIfAvailable;
string param = "Unknown";
try
{
// Need to set these separately, because they don't require a CommitChanges to the C# compiler in the IDE.
param = "LinkResources"; this.CheckHostObjectSupport(param, cscHostObject.SetLinkResources(this.LinkResources));
param = "References"; this.CheckHostObjectSupport(param, cscHostObject.SetReferences(this.References));
param = "Resources"; this.CheckHostObjectSupport(param, cscHostObject.SetResources(this.Resources));
param = "Sources"; this.CheckHostObjectSupport(param, cscHostObject.SetSources(this.Sources));
// For host objects which support it, pass the list of analyzers.
IAnalyzerHostObject analyzerHostObject = cscHostObject as IAnalyzerHostObject;
if (analyzerHostObject != null)
{
param = "Analyzers"; this.CheckHostObjectSupport(param, analyzerHostObject.SetAnalyzers(this.Analyzers));
}
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
if (this.HostCompilerSupportsAllParameters)
{
// If the host compiler doesn't support everything we need, we're going to end up
// shelling out to the command-line compiler anyway. That means the command-line
// compiler will log the error. So here, we only log the error if we would've
// tried to use the host compiler.
Log.LogErrorWithCodeFromResources("General.CouldNotSetHostObjectParameter", param, e.Message);
}
return false;
}
try
{
param = "BeginInitialization";
cscHostObject.BeginInitialization();
param = "AdditionalLibPaths"; this.CheckHostObjectSupport(param, cscHostObject.SetAdditionalLibPaths(this.AdditionalLibPaths));
param = "AddModules"; this.CheckHostObjectSupport(param, cscHostObject.SetAddModules(this.AddModules));
param = "AllowUnsafeBlocks"; this.CheckHostObjectSupport(param, cscHostObject.SetAllowUnsafeBlocks(this.AllowUnsafeBlocks));
param = "BaseAddress"; this.CheckHostObjectSupport(param, cscHostObject.SetBaseAddress(this.BaseAddress));
param = "CheckForOverflowUnderflow"; this.CheckHostObjectSupport(param, cscHostObject.SetCheckForOverflowUnderflow(this.CheckForOverflowUnderflow));
param = "CodePage"; this.CheckHostObjectSupport(param, cscHostObject.SetCodePage(this.CodePage));
// These two -- EmitDebugInformation and DebugType -- must go together, with DebugType
// getting set last, because it is more specific.
param = "EmitDebugInformation"; this.CheckHostObjectSupport(param, cscHostObject.SetEmitDebugInformation(this.EmitDebugInformation));
param = "DebugType"; this.CheckHostObjectSupport(param, cscHostObject.SetDebugType(this.DebugType));
param = "DefineConstants"; this.CheckHostObjectSupport(param, cscHostObject.SetDefineConstants(this.GetDefineConstantsSwitch(this.DefineConstants)));
param = "DelaySign"; this.CheckHostObjectSupport(param, cscHostObject.SetDelaySign((this.Bag["DelaySign"] != null), this.DelaySign));
param = "DisabledWarnings"; this.CheckHostObjectSupport(param, cscHostObject.SetDisabledWarnings(this.DisabledWarnings));
param = "DocumentationFile"; this.CheckHostObjectSupport(param, cscHostObject.SetDocumentationFile(this.DocumentationFile));
param = "ErrorReport"; this.CheckHostObjectSupport(param, cscHostObject.SetErrorReport(this.ErrorReport));
param = "FileAlignment"; this.CheckHostObjectSupport(param, cscHostObject.SetFileAlignment(this.FileAlignment));
param = "GenerateFullPaths"; this.CheckHostObjectSupport(param, cscHostObject.SetGenerateFullPaths(this.GenerateFullPaths));
param = "KeyContainer"; this.CheckHostObjectSupport(param, cscHostObject.SetKeyContainer(this.KeyContainer));
param = "KeyFile"; this.CheckHostObjectSupport(param, cscHostObject.SetKeyFile(this.KeyFile));
param = "LangVersion"; this.CheckHostObjectSupport(param, cscHostObject.SetLangVersion(this.LangVersion));
param = "MainEntryPoint"; this.CheckHostObjectSupport(param, cscHostObject.SetMainEntryPoint(this.TargetType, this.MainEntryPoint));
param = "ModuleAssemblyName"; this.CheckHostObjectSupport(param, cscHostObject.SetModuleAssemblyName(this.ModuleAssemblyName));
param = "NoConfig"; this.CheckHostObjectSupport(param, cscHostObject.SetNoConfig(this.NoConfig));
param = "NoStandardLib"; this.CheckHostObjectSupport(param, cscHostObject.SetNoStandardLib(this.NoStandardLib));
param = "Optimize"; this.CheckHostObjectSupport(param, cscHostObject.SetOptimize(this.Optimize));
param = "OutputAssembly"; this.CheckHostObjectSupport(param, cscHostObject.SetOutputAssembly(this.OutputAssembly.ItemSpec));
param = "PdbFile"; this.CheckHostObjectSupport(param, cscHostObject.SetPdbFile(this.PdbFile));
// For host objects which support it, set platform with 32BitPreference, HighEntropyVA, and SubsystemVersion
ICscHostObject4 cscHostObject4 = cscHostObject as ICscHostObject4;
if (cscHostObject4 != null)
{
param = "PlatformWith32BitPreference"; this.CheckHostObjectSupport(param, cscHostObject4.SetPlatformWith32BitPreference(this.PlatformWith32BitPreference));
param = "HighEntropyVA"; this.CheckHostObjectSupport(param, cscHostObject4.SetHighEntropyVA(this.HighEntropyVA));
param = "SubsystemVersion"; this.CheckHostObjectSupport(param, cscHostObject4.SetSubsystemVersion(this.SubsystemVersion));
}
else
{
param = "Platform"; this.CheckHostObjectSupport(param, cscHostObject.SetPlatform(this.Platform));
}
// For host objects which support it, set the analyzer ruleset and additional files.
IAnalyzerHostObject analyzerHostObject = cscHostObject as IAnalyzerHostObject;
if (analyzerHostObject != null)
{
param = "CodeAnalysisRuleSet"; this.CheckHostObjectSupport(param, analyzerHostObject.SetRuleSet(this.CodeAnalysisRuleSet));
param = "AdditionalFiles"; this.CheckHostObjectSupport(param, analyzerHostObject.SetAdditionalFiles(this.AdditionalFiles));
}
param = "ResponseFiles"; this.CheckHostObjectSupport(param, cscHostObject.SetResponseFiles(this.ResponseFiles));
param = "TargetType"; this.CheckHostObjectSupport(param, cscHostObject.SetTargetType(this.TargetType));
param = "TreatWarningsAsErrors"; this.CheckHostObjectSupport(param, cscHostObject.SetTreatWarningsAsErrors(this.TreatWarningsAsErrors));
param = "WarningLevel"; this.CheckHostObjectSupport(param, cscHostObject.SetWarningLevel(this.WarningLevel));
// This must come after TreatWarningsAsErrors.
param = "WarningsAsErrors"; this.CheckHostObjectSupport(param, cscHostObject.SetWarningsAsErrors(this.WarningsAsErrors));
// This must come after TreatWarningsAsErrors.
param = "WarningsNotAsErrors"; this.CheckHostObjectSupport(param, cscHostObject.SetWarningsNotAsErrors(this.WarningsNotAsErrors));
param = "Win32Icon"; this.CheckHostObjectSupport(param, cscHostObject.SetWin32Icon(this.Win32Icon));
// In order to maintain compatibility with previous host compilers, we must
// light-up for ICscHostObject2/ICscHostObject3
if (cscHostObject is ICscHostObject2)
{
ICscHostObject2 cscHostObject2 = (ICscHostObject2)cscHostObject;
param = "Win32Manifest"; this.CheckHostObjectSupport(param, cscHostObject2.SetWin32Manifest(this.GetWin32ManifestSwitch(this.NoWin32Manifest, this.Win32Manifest)));
}
else
{
// If we have been given a property that the host compiler doesn't support
// then we need to state that we are falling back to the command line compiler
if (!String.IsNullOrEmpty(Win32Manifest))
{
this.CheckHostObjectSupport("Win32Manifest", false);
}
}
// This must come after Win32Manifest
param = "Win32Resource"; this.CheckHostObjectSupport(param, cscHostObject.SetWin32Resource(this.Win32Resource));
if (cscHostObject is ICscHostObject3)
{
ICscHostObject3 cscHostObject3 = (ICscHostObject3)cscHostObject;
param = "ApplicationConfiguration"; this.CheckHostObjectSupport(param, cscHostObject3.SetApplicationConfiguration(this.ApplicationConfiguration));
}
else
{
// If we have been given a property that the host compiler doesn't support
// then we need to state that we are falling back to the command line compiler
if (!String.IsNullOrEmpty(ApplicationConfiguration))
{
this.CheckHostObjectSupport("ApplicationConfiguration", false);
}
}
// If we have been given a property value that the host compiler doesn't support
// then we need to state that we are falling back to the command line compiler.
// Null is supported because it means that option should be omitted, and compiler default used - obviously always valid.
// Explicitly specified name of current locale is also supported, since it is effectively a no-op.
// Other options are not supported since in-proc compiler always uses current locale.
if (!String.IsNullOrEmpty(PreferredUILang) && !String.Equals(PreferredUILang, System.Globalization.CultureInfo.CurrentUICulture.Name, StringComparison.OrdinalIgnoreCase))
{
this.CheckHostObjectSupport("PreferredUILang", false);
}
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
if (this.HostCompilerSupportsAllParameters)
{
// If the host compiler doesn't support everything we need, we're going to end up
// shelling out to the command-line compiler anyway. That means the command-line
// compiler will log the error. So here, we only log the error if we would've
// tried to use the host compiler.
Log.LogErrorWithCodeFromResources("General.CouldNotSetHostObjectParameter", param, e.Message);
}
return false;
}
finally
{
int errorCode;
string errorMessage;
success = cscHostObject.EndInitialization(out errorMessage, out errorCode);
if (this.HostCompilerSupportsAllParameters)
{
// If the host compiler doesn't support everything we need, we're going to end up
// shelling out to the command-line compiler anyway. That means the command-line
// compiler will log the error. So here, we only log the error if we would've
// tried to use the host compiler.
// If EndInitialization returns false, then there was an error. If EndInitialization was
// successful, but there is a valid 'errorMessage,' interpret it as a warning.
if (!success)
{
Log.LogError(null, "CS" + errorCode.ToString("D4", CultureInfo.InvariantCulture), null, null, 0, 0, 0, 0, errorMessage);
}
else if (errorMessage != null && errorMessage.Length > 0)
{
Log.LogWarning(null, "CS" + errorCode.ToString("D4", CultureInfo.InvariantCulture), null, null, 0, 0, 0, 0, errorMessage);
}
}
}
return (success);
}
/// <summary>
/// This method will get called during Execute() if a host object has been passed into the Csc
/// task. Returns one of the following values to indicate what the next action should be:
/// UseHostObjectToExecute Host compiler exists and was initialized.
/// UseAlternateToolToExecute Host compiler doesn't exist or was not appropriate.
/// NoActionReturnSuccess Host compiler was already up-to-date, and we're done.
/// NoActionReturnFailure Bad parameters were passed into the task.
/// </summary>
override protected HostObjectInitializationStatus InitializeHostObject()
{
if (this.HostObject != null)
{
// When the host object was passed into the task, it was passed in as a generic
// "Object" (because ITask interface obviously can't have any Csc-specific stuff
// in it, and each task is going to want to communicate with its host in a unique
// way). Now we cast it to the specific type that the Csc task expects. If the
// host object does not match this type, the host passed in an invalid host object
// to Csc, and we error out.
// NOTE: For compat reasons this must remain ICscHostObject
// we can dynamically test for smarter interfaces later..
using (RCWForCurrentContext<ICscHostObject> hostObject = new RCWForCurrentContext<ICscHostObject>(this.HostObject as ICscHostObject))
{
ICscHostObject cscHostObject = hostObject.RCW;
if (cscHostObject != null)
{
bool hostObjectSuccessfullyInitialized = InitializeHostCompiler(cscHostObject);
// If we're currently only in design-time (as opposed to build-time),
// then we're done. We've initialized the host compiler as best we
// can, and we certainly don't want to actually do the final compile.
// So return true, saying we're done and successful.
if (cscHostObject.IsDesignTime())
{
// If we are design-time then we do not want to continue the build at
// this time.
return hostObjectSuccessfullyInitialized ?
HostObjectInitializationStatus.NoActionReturnSuccess :
HostObjectInitializationStatus.NoActionReturnFailure;
}
if (!this.HostCompilerSupportsAllParameters || UseAlternateCommandLineToolToExecute())
{
// Since the host compiler has refused to take on the responsibility for this compilation,
// we're about to shell out to the command-line compiler to handle it. If some of the
// references don't exist on disk, we know the command-line compiler will fail, so save
// the trouble, and just throw a consistent error ourselves. This allows us to give
// more information than the compiler would, and also make things consistent across
// Vbc / Csc / etc.
// This suite behaves differently in localized builds than on English builds because
// VBC.EXE doesn't localize the word "error" when they emit errors and so we can't scan for it.
if (!CheckAllReferencesExistOnDisk())
{
return HostObjectInitializationStatus.NoActionReturnFailure;
}
// The host compiler doesn't support some of the switches/parameters
// being passed to it. Therefore, we resort to using the command-line compiler
// in this case.
UsedCommandLineTool = true;
return HostObjectInitializationStatus.UseAlternateToolToExecute;
}
// Ok, by now we validated that the host object supports the necessary switches
// and parameters. Last thing to check is whether the host object is up to date,
// and in that case, we will inform the caller that no further action is necessary.
if (hostObjectSuccessfullyInitialized)
{
return cscHostObject.IsUpToDate() ?
HostObjectInitializationStatus.NoActionReturnSuccess :
HostObjectInitializationStatus.UseHostObjectToExecute;
}
else
{
return HostObjectInitializationStatus.NoActionReturnFailure;
}
}
else
{
Log.LogErrorWithCodeFromResources("General.IncorrectHostObject", "Csc", "ICscHostObject");
}
}
}
// No appropriate host object was found.
UsedCommandLineTool = true;
return HostObjectInitializationStatus.UseAlternateToolToExecute;
}
/// <summary>
/// This method will get called during Execute() if a host object has been passed into the Csc
/// task. Returns true if the compilation succeeded, otherwise false.
/// </summary>
override protected bool CallHostObjectToExecute()
{
Debug.Assert(this.HostObject != null, "We should not be here if the host object has not been set.");
ICscHostObject cscHostObject = this.HostObject as ICscHostObject;
Debug.Assert(cscHostObject != null, "Wrong kind of host object passed in!");
try
{
#if (!STANDALONEBUILD)
CodeMarkers.Instance.CodeMarker(CodeMarkerEvent.perfMSBuildHostCompileBegin);
#endif
return cscHostObject.Compile();
}
finally
{
#if (!STANDALONEBUILD)
CodeMarkers.Instance.CodeMarker(CodeMarkerEvent.perfMSBuildHostCompileEnd);
#endif
}
}
}
}
| mit |
Teamxrtc/webrtc-streaming-node | third_party/webrtc/src/chromium/src/third_party/opus/src/celt/dump_modes/Makefile | 304 | CFLAGS=-O2 -Wall -Wextra -DHAVE_CONFIG_H
INCLUDES=-I../ -I../.. -I../../include
all: dump_modes
dump_modes:
$(CC) $(CFLAGS) $(INCLUDES) -DCUSTOM_MODES dump_modes.c ../modes.c ../cwrs.c ../rate.c ../entenc.c ../entdec.c ../mathops.c ../mdct.c ../kiss_fft.c -o dump_modes -lm
clean:
rm -f dump_modes
| mit |
sunkeqin/linux-2.6.11 | drivers/media/dvb/frontends/mt312.c | 17683 | /*
Driver for Zarlink VP310/MT312 Satellite Channel Decoder
Copyright (C) 2003 Andreas Oberritter <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
References:
http://products.zarlink.com/product_profiles/MT312.htm
http://products.zarlink.com/product_profiles/SL1935.htm
*/
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include "dvb_frontend.h"
#include "mt312_priv.h"
#include "mt312.h"
struct mt312_state {
struct i2c_adapter* i2c;
struct dvb_frontend_ops ops;
/* configuration settings */
const struct mt312_config* config;
struct dvb_frontend frontend;
u8 id;
u8 frequency;
};
static int debug;
#define dprintk(args...) \
do { \
if (debug) printk(KERN_DEBUG "mt312: " args); \
} while (0)
#define MT312_SYS_CLK 90000000UL /* 90 MHz */
#define MT312_LPOWER_SYS_CLK 60000000UL /* 60 MHz */
#define MT312_PLL_CLK 10000000UL /* 10 MHz */
static int mt312_read(struct mt312_state* state, const enum mt312_reg_addr reg,
void *buf, const size_t count)
{
int ret;
struct i2c_msg msg[2];
u8 regbuf[1] = { reg };
msg[0].addr = state->config->demod_address;
msg[0].flags = 0;
msg[0].buf = regbuf;
msg[0].len = 1;
msg[1].addr = state->config->demod_address;
msg[1].flags = I2C_M_RD;
msg[1].buf = buf;
msg[1].len = count;
ret = i2c_transfer(state->i2c, msg, 2);
if (ret != 2) {
printk(KERN_ERR "%s: ret == %d\n", __FUNCTION__, ret);
return -EREMOTEIO;
}
if(debug) {
int i;
dprintk("R(%d):", reg & 0x7f);
for (i = 0; i < count; i++)
printk(" %02x", ((const u8 *) buf)[i]);
printk("\n");
}
return 0;
}
static int mt312_write(struct mt312_state* state, const enum mt312_reg_addr reg,
const void *src, const size_t count)
{
int ret;
u8 buf[count + 1];
struct i2c_msg msg;
if(debug) {
int i;
dprintk("W(%d):", reg & 0x7f);
for (i = 0; i < count; i++)
printk(" %02x", ((const u8 *) src)[i]);
printk("\n");
}
buf[0] = reg;
memcpy(&buf[1], src, count);
msg.addr = state->config->demod_address;
msg.flags = 0;
msg.buf = buf;
msg.len = count + 1;
ret = i2c_transfer(state->i2c, &msg, 1);
if (ret != 1) {
dprintk("%s: ret == %d\n", __FUNCTION__, ret);
return -EREMOTEIO;
}
return 0;
}
static inline int mt312_readreg(struct mt312_state* state,
const enum mt312_reg_addr reg, u8 * val)
{
return mt312_read(state, reg, val, 1);
}
static inline int mt312_writereg(struct mt312_state* state,
const enum mt312_reg_addr reg, const u8 val)
{
return mt312_write(state, reg, &val, 1);
}
static inline u32 mt312_div(u32 a, u32 b)
{
return (a + (b / 2)) / b;
}
static int mt312_reset(struct mt312_state* state, const u8 full)
{
return mt312_writereg(state, RESET, full ? 0x80 : 0x40);
}
static int mt312_get_inversion(struct mt312_state* state,
fe_spectral_inversion_t *i)
{
int ret;
u8 vit_mode;
if ((ret = mt312_readreg(state, VIT_MODE, &vit_mode)) < 0)
return ret;
if (vit_mode & 0x80) /* auto inversion was used */
*i = (vit_mode & 0x40) ? INVERSION_ON : INVERSION_OFF;
return 0;
}
static int mt312_get_symbol_rate(struct mt312_state* state, u32 *sr)
{
int ret;
u8 sym_rate_h;
u8 dec_ratio;
u16 sym_rat_op;
u16 monitor;
u8 buf[2];
if ((ret = mt312_readreg(state, SYM_RATE_H, &sym_rate_h)) < 0)
return ret;
if (sym_rate_h & 0x80) { /* symbol rate search was used */
if ((ret = mt312_writereg(state, MON_CTRL, 0x03)) < 0)
return ret;
if ((ret = mt312_read(state, MONITOR_H, buf, sizeof(buf))) < 0)
return ret;
monitor = (buf[0] << 8) | buf[1];
dprintk(KERN_DEBUG "sr(auto) = %u\n",
mt312_div(monitor * 15625, 4));
} else {
if ((ret = mt312_writereg(state, MON_CTRL, 0x05)) < 0)
return ret;
if ((ret = mt312_read(state, MONITOR_H, buf, sizeof(buf))) < 0)
return ret;
dec_ratio = ((buf[0] >> 5) & 0x07) * 32;
if ((ret = mt312_read(state, SYM_RAT_OP_H, buf, sizeof(buf))) < 0)
return ret;
sym_rat_op = (buf[0] << 8) | buf[1];
dprintk(KERN_DEBUG "sym_rat_op=%d dec_ratio=%d\n",
sym_rat_op, dec_ratio);
dprintk(KERN_DEBUG "*sr(manual) = %lu\n",
(((MT312_PLL_CLK * 8192) / (sym_rat_op + 8192)) *
2) - dec_ratio);
}
return 0;
}
static int mt312_get_code_rate(struct mt312_state* state, fe_code_rate_t *cr)
{
const fe_code_rate_t fec_tab[8] =
{ FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_6_7, FEC_7_8,
FEC_AUTO, FEC_AUTO };
int ret;
u8 fec_status;
if ((ret = mt312_readreg(state, FEC_STATUS, &fec_status)) < 0)
return ret;
*cr = fec_tab[(fec_status >> 4) & 0x07];
return 0;
}
static int mt312_initfe(struct dvb_frontend* fe)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[2];
/* wake up */
if ((ret = mt312_writereg(state, CONFIG, (state->frequency == 60 ? 0x88 : 0x8c))) < 0)
return ret;
/* wait at least 150 usec */
udelay(150);
/* full reset */
if ((ret = mt312_reset(state, 1)) < 0)
return ret;
// Per datasheet, write correct values. 09/28/03 ACCJr.
// If we don't do this, we won't get FE_HAS_VITERBI in the VP310.
{
u8 buf_def[8]={0x14, 0x12, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00};
if ((ret = mt312_write(state, VIT_SETUP, buf_def, sizeof(buf_def))) < 0)
return ret;
}
/* SYS_CLK */
buf[0] = mt312_div((state->frequency == 60 ? MT312_LPOWER_SYS_CLK : MT312_SYS_CLK) * 2, 1000000);
/* DISEQC_RATIO */
buf[1] = mt312_div(MT312_PLL_CLK, 15000 * 4);
if ((ret = mt312_write(state, SYS_CLK, buf, sizeof(buf))) < 0)
return ret;
if ((ret = mt312_writereg(state, SNR_THS_HIGH, 0x32)) < 0)
return ret;
if ((ret = mt312_writereg(state, OP_CTRL, 0x53)) < 0)
return ret;
/* TS_SW_LIM */
buf[0] = 0x8c;
buf[1] = 0x98;
if ((ret = mt312_write(state, TS_SW_LIM_L, buf, sizeof(buf))) < 0)
return ret;
if ((ret = mt312_writereg(state, CS_SW_LIM, 0x69)) < 0)
return ret;
if (state->config->pll_init) {
mt312_writereg(state, GPP_CTRL, 0x40);
state->config->pll_init(fe);
mt312_writereg(state, GPP_CTRL, 0x00);
}
return 0;
}
static int mt312_send_master_cmd(struct dvb_frontend* fe,
struct dvb_diseqc_master_cmd *c)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 diseqc_mode;
if ((c->msg_len == 0) || (c->msg_len > sizeof(c->msg)))
return -EINVAL;
if ((ret = mt312_readreg(state, DISEQC_MODE, &diseqc_mode)) < 0)
return ret;
if ((ret =
mt312_write(state, (0x80 | DISEQC_INSTR), c->msg, c->msg_len)) < 0)
return ret;
if ((ret =
mt312_writereg(state, DISEQC_MODE,
(diseqc_mode & 0x40) | ((c->msg_len - 1) << 3)
| 0x04)) < 0)
return ret;
/* set DISEQC_MODE[2:0] to zero if a return message is expected */
if (c->msg[0] & 0x02)
if ((ret =
mt312_writereg(state, DISEQC_MODE, (diseqc_mode & 0x40))) < 0)
return ret;
return 0;
}
static int mt312_send_burst(struct dvb_frontend* fe, const fe_sec_mini_cmd_t c)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
const u8 mini_tab[2] = { 0x02, 0x03 };
int ret;
u8 diseqc_mode;
if (c > SEC_MINI_B)
return -EINVAL;
if ((ret = mt312_readreg(state, DISEQC_MODE, &diseqc_mode)) < 0)
return ret;
if ((ret =
mt312_writereg(state, DISEQC_MODE,
(diseqc_mode & 0x40) | mini_tab[c])) < 0)
return ret;
return 0;
}
static int mt312_set_tone(struct dvb_frontend* fe, const fe_sec_tone_mode_t t)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
const u8 tone_tab[2] = { 0x01, 0x00 };
int ret;
u8 diseqc_mode;
if (t > SEC_TONE_OFF)
return -EINVAL;
if ((ret = mt312_readreg(state, DISEQC_MODE, &diseqc_mode)) < 0)
return ret;
if ((ret =
mt312_writereg(state, DISEQC_MODE,
(diseqc_mode & 0x40) | tone_tab[t])) < 0)
return ret;
return 0;
}
static int mt312_set_voltage(struct dvb_frontend* fe, const fe_sec_voltage_t v)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
const u8 volt_tab[3] = { 0x00, 0x40, 0x00 };
if (v > SEC_VOLTAGE_OFF)
return -EINVAL;
return mt312_writereg(state, DISEQC_MODE, volt_tab[v]);
}
static int mt312_read_status(struct dvb_frontend* fe, fe_status_t *s)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 status[3];
*s = 0;
if ((ret = mt312_read(state, QPSK_STAT_H, status, sizeof(status))) < 0)
return ret;
dprintk(KERN_DEBUG "QPSK_STAT_H: 0x%02x, QPSK_STAT_L: 0x%02x, FEC_STATUS: 0x%02x\n", status[0], status[1], status[2]);
if (status[0] & 0xc0)
*s |= FE_HAS_SIGNAL; /* signal noise ratio */
if (status[0] & 0x04)
*s |= FE_HAS_CARRIER; /* qpsk carrier lock */
if (status[2] & 0x02)
*s |= FE_HAS_VITERBI; /* viterbi lock */
if (status[2] & 0x04)
*s |= FE_HAS_SYNC; /* byte align lock */
if (status[0] & 0x01)
*s |= FE_HAS_LOCK; /* qpsk lock */
return 0;
}
static int mt312_read_ber(struct dvb_frontend* fe, u32 *ber)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[3];
if ((ret = mt312_read(state, RS_BERCNT_H, buf, 3)) < 0)
return ret;
*ber = ((buf[0] << 16) | (buf[1] << 8) | buf[2]) * 64;
return 0;
}
static int mt312_read_signal_strength(struct dvb_frontend* fe, u16 *signal_strength)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[3];
u16 agc;
s16 err_db;
if ((ret = mt312_read(state, AGC_H, buf, sizeof(buf))) < 0)
return ret;
agc = (buf[0] << 6) | (buf[1] >> 2);
err_db = (s16) (((buf[1] & 0x03) << 14) | buf[2] << 6) >> 6;
*signal_strength = agc;
dprintk(KERN_DEBUG "agc=%08x err_db=%hd\n", agc, err_db);
return 0;
}
static int mt312_read_snr(struct dvb_frontend* fe, u16 *snr)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[2];
if ((ret = mt312_read(state, M_SNR_H, &buf, sizeof(buf))) < 0)
return ret;
*snr = 0xFFFF - ((((buf[0] & 0x7f) << 8) | buf[1]) << 1);
return 0;
}
static int mt312_read_ucblocks(struct dvb_frontend* fe, u32 *ubc)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[2];
if ((ret = mt312_read(state, RS_UBC_H, &buf, sizeof(buf))) < 0)
return ret;
*ubc = (buf[0] << 8) | buf[1];
return 0;
}
static int mt312_set_frontend(struct dvb_frontend* fe,
struct dvb_frontend_parameters *p)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 buf[5], config_val;
u16 sr;
const u8 fec_tab[10] =
{ 0x00, 0x01, 0x02, 0x04, 0x3f, 0x08, 0x10, 0x20, 0x3f, 0x3f };
const u8 inv_tab[3] = { 0x00, 0x40, 0x80 };
dprintk("%s: Freq %d\n", __FUNCTION__, p->frequency);
if ((p->frequency < fe->ops->info.frequency_min)
|| (p->frequency > fe->ops->info.frequency_max))
return -EINVAL;
if ((p->inversion < INVERSION_OFF)
|| (p->inversion > INVERSION_ON))
return -EINVAL;
if ((p->u.qpsk.symbol_rate < fe->ops->info.symbol_rate_min)
|| (p->u.qpsk.symbol_rate > fe->ops->info.symbol_rate_max))
return -EINVAL;
if ((p->u.qpsk.fec_inner < FEC_NONE)
|| (p->u.qpsk.fec_inner > FEC_AUTO))
return -EINVAL;
if ((p->u.qpsk.fec_inner == FEC_4_5)
|| (p->u.qpsk.fec_inner == FEC_8_9))
return -EINVAL;
switch (state->id) {
case ID_VP310:
// For now we will do this only for the VP310.
// It should be better for the mt312 as well, but tunning will be slower. ACCJr 09/29/03
if ((ret = mt312_readreg(state, CONFIG, &config_val) < 0))
return ret;
if (p->u.qpsk.symbol_rate >= 30000000) //Note that 30MS/s should use 90MHz
{
if ((config_val & 0x0c) == 0x08) { //We are running 60MHz
state->frequency = 90;
if ((ret = mt312_initfe(fe)) < 0)
return ret;
}
}
else
{
if ((config_val & 0x0c) == 0x0C) { //We are running 90MHz
state->frequency = 60;
if ((ret = mt312_initfe(fe)) < 0)
return ret;
}
}
break;
case ID_MT312:
break;
default:
return -EINVAL;
}
mt312_writereg(state, GPP_CTRL, 0x40);
state->config->pll_set(fe, p);
mt312_writereg(state, GPP_CTRL, 0x00);
/* sr = (u16)(sr * 256.0 / 1000000.0) */
sr = mt312_div(p->u.qpsk.symbol_rate * 4, 15625);
/* SYM_RATE */
buf[0] = (sr >> 8) & 0x3f;
buf[1] = (sr >> 0) & 0xff;
/* VIT_MODE */
buf[2] = inv_tab[p->inversion] | fec_tab[p->u.qpsk.fec_inner];
/* QPSK_CTRL */
buf[3] = 0x40; /* swap I and Q before QPSK demodulation */
if (p->u.qpsk.symbol_rate < 10000000)
buf[3] |= 0x04; /* use afc mode */
/* GO */
buf[4] = 0x01;
if ((ret = mt312_write(state, SYM_RATE_H, buf, sizeof(buf))) < 0)
return ret;
mt312_reset(state, 0);
return 0;
}
static int mt312_get_frontend(struct dvb_frontend* fe,
struct dvb_frontend_parameters *p)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
if ((ret = mt312_get_inversion(state, &p->inversion)) < 0)
return ret;
if ((ret = mt312_get_symbol_rate(state, &p->u.qpsk.symbol_rate)) < 0)
return ret;
if ((ret = mt312_get_code_rate(state, &p->u.qpsk.fec_inner)) < 0)
return ret;
return 0;
}
static int mt312_sleep(struct dvb_frontend* fe)
{
struct mt312_state *state = (struct mt312_state*) fe->demodulator_priv;
int ret;
u8 config;
/* reset all registers to defaults */
if ((ret = mt312_reset(state, 1)) < 0)
return ret;
if ((ret = mt312_readreg(state, CONFIG, &config)) < 0)
return ret;
/* enter standby */
if ((ret = mt312_writereg(state, CONFIG, config & 0x7f)) < 0)
return ret;
return 0;
}
static int mt312_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
{
fesettings->min_delay_ms = 50;
fesettings->step_size = 0;
fesettings->max_drift = 0;
return 0;
}
static void mt312_release(struct dvb_frontend* fe)
{
struct mt312_state* state = (struct mt312_state*) fe->demodulator_priv;
kfree(state);
}
static struct dvb_frontend_ops vp310_mt312_ops;
struct dvb_frontend* vp310_attach(const struct mt312_config* config,
struct i2c_adapter* i2c)
{
struct mt312_state* state = NULL;
/* allocate memory for the internal state */
state = (struct mt312_state*) kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
if (state == NULL)
goto error;
/* setup the state */
state->config = config;
state->i2c = i2c;
memcpy(&state->ops, &vp310_mt312_ops, sizeof(struct dvb_frontend_ops));
strcpy(state->ops.info.name, "Zarlink VP310 DVB-S");
/* check if the demod is there */
if (mt312_readreg(state, ID, &state->id) < 0)
goto error;
if (state->id != ID_VP310) {
goto error;
}
/* create dvb_frontend */
state->frequency = 90;
state->frontend.ops = &state->ops;
state->frontend.demodulator_priv = state;
return &state->frontend;
error:
if (state)
kfree(state);
return NULL;
}
struct dvb_frontend* mt312_attach(const struct mt312_config* config,
struct i2c_adapter* i2c)
{
struct mt312_state* state = NULL;
/* allocate memory for the internal state */
state = (struct mt312_state*) kmalloc(sizeof(struct mt312_state), GFP_KERNEL);
if (state == NULL)
goto error;
/* setup the state */
state->config = config;
state->i2c = i2c;
memcpy(&state->ops, &vp310_mt312_ops, sizeof(struct dvb_frontend_ops));
strcpy(state->ops.info.name, "Zarlink MT312 DVB-S");
/* check if the demod is there */
if (mt312_readreg(state, ID, &state->id) < 0)
goto error;
if (state->id != ID_MT312) {
goto error;
}
/* create dvb_frontend */
state->frequency = 60;
state->frontend.ops = &state->ops;
state->frontend.demodulator_priv = state;
return &state->frontend;
error:
if (state)
kfree(state);
return NULL;
}
static struct dvb_frontend_ops vp310_mt312_ops = {
.info = {
.name = "Zarlink ???? DVB-S",
.type = FE_QPSK,
.frequency_min = 950000,
.frequency_max = 2150000,
.frequency_stepsize = (MT312_PLL_CLK / 1000) / 128,
.symbol_rate_min = MT312_SYS_CLK / 128,
.symbol_rate_max = MT312_SYS_CLK / 2,
.caps =
FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
FE_CAN_FEC_AUTO | FE_CAN_QPSK | FE_CAN_MUTE_TS |
FE_CAN_RECOVER
},
.release = mt312_release,
.init = mt312_initfe,
.sleep = mt312_sleep,
.set_frontend = mt312_set_frontend,
.get_frontend = mt312_get_frontend,
.get_tune_settings = mt312_get_tune_settings,
.read_status = mt312_read_status,
.read_ber = mt312_read_ber,
.read_signal_strength = mt312_read_signal_strength,
.read_snr = mt312_read_snr,
.read_ucblocks = mt312_read_ucblocks,
.diseqc_send_master_cmd = mt312_send_master_cmd,
.diseqc_send_burst = mt312_send_burst,
.set_tone = mt312_set_tone,
.set_voltage = mt312_set_voltage,
};
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
MODULE_DESCRIPTION("Zarlink VP310/MT312 DVB-S Demodulator driver");
MODULE_AUTHOR("Andreas Oberritter <[email protected]>");
MODULE_LICENSE("GPL");
EXPORT_SYMBOL(mt312_attach);
EXPORT_SYMBOL(vp310_attach);
| gpl-2.0 |
kirsley/repobase | wp-admin/plugins.php | 24347 | <?php
/**
* Plugins administration panel.
*
* @package WordPress
* @subpackage Administration
*/
/** WordPress Administration Bootstrap */
require_once( dirname( __FILE__ ) . '/admin.php' );
if ( ! current_user_can( 'activate_plugins' ) ) {
wp_die( __( 'Sorry, you are not allowed to manage plugins for this site.' ) );
}
$wp_list_table = _get_list_table( 'WP_Plugins_List_Table' );
$pagenum = $wp_list_table->get_pagenum();
$action = $wp_list_table->current_action();
$plugin = isset( $_REQUEST['plugin'] ) ? wp_unslash( $_REQUEST['plugin'] ) : '';
$s = isset( $_REQUEST['s'] ) ? urlencode( wp_unslash( $_REQUEST['s'] ) ) : '';
// Clean up request URI from temporary args for screen options/paging uri's to work as expected.
$_SERVER['REQUEST_URI'] = remove_query_arg( array( 'error', 'deleted', 'activate', 'activate-multi', 'deactivate', 'deactivate-multi', '_error_nonce' ), $_SERVER['REQUEST_URI'] );
wp_enqueue_script( 'updates' );
if ( $action ) {
switch ( $action ) {
case 'activate':
if ( ! current_user_can( 'activate_plugin', $plugin ) ) {
wp_die( __( 'Sorry, you are not allowed to activate this plugin.' ) );
}
if ( is_multisite() && ! is_network_admin() && is_network_only_plugin( $plugin ) ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
check_admin_referer( 'activate-plugin_' . $plugin );
$result = activate_plugin( $plugin, self_admin_url( 'plugins.php?error=true&plugin=' . urlencode( $plugin ) ), is_network_admin() );
if ( is_wp_error( $result ) ) {
if ( 'unexpected_output' == $result->get_error_code() ) {
$redirect = self_admin_url( 'plugins.php?error=true&charsout=' . strlen( $result->get_error_data() ) . '&plugin=' . urlencode( $plugin ) . "&plugin_status=$status&paged=$page&s=$s" );
wp_redirect( add_query_arg( '_error_nonce', wp_create_nonce( 'plugin-activation-error_' . $plugin ), $redirect ) );
exit;
} else {
wp_die( $result );
}
}
if ( ! is_network_admin() ) {
$recent = (array) get_option( 'recently_activated' );
unset( $recent[ $plugin ] );
update_option( 'recently_activated', $recent );
} else {
$recent = (array) get_site_option( 'recently_activated' );
unset( $recent[ $plugin ] );
update_site_option( 'recently_activated', $recent );
}
if ( isset( $_GET['from'] ) && 'import' == $_GET['from'] ) {
wp_redirect( self_admin_url( 'import.php?import=' . str_replace( '-importer', '', dirname( $plugin ) ) ) ); // overrides the ?error=true one above and redirects to the Imports page, stripping the -importer suffix
} elseif ( isset( $_GET['from'] ) && 'press-this' == $_GET['from'] ) {
wp_redirect( self_admin_url( 'press-this.php' ) );
} else {
wp_redirect( self_admin_url( "plugins.php?activate=true&plugin_status=$status&paged=$page&s=$s" ) ); // overrides the ?error=true one above
}
exit;
case 'activate-selected':
if ( ! current_user_can( 'activate_plugins' ) ) {
wp_die( __( 'Sorry, you are not allowed to activate plugins for this site.' ) );
}
check_admin_referer( 'bulk-plugins' );
$plugins = isset( $_POST['checked'] ) ? (array) wp_unslash( $_POST['checked'] ) : array();
if ( is_network_admin() ) {
foreach ( $plugins as $i => $plugin ) {
// Only activate plugins which are not already network activated.
if ( is_plugin_active_for_network( $plugin ) ) {
unset( $plugins[ $i ] );
}
}
} else {
foreach ( $plugins as $i => $plugin ) {
// Only activate plugins which are not already active and are not network-only when on Multisite.
if ( is_plugin_active( $plugin ) || ( is_multisite() && is_network_only_plugin( $plugin ) ) ) {
unset( $plugins[ $i ] );
}
// Only activate plugins which the user can activate.
if ( ! current_user_can( 'activate_plugin', $plugin ) ) {
unset( $plugins[ $i ] );
}
}
}
if ( empty( $plugins ) ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
activate_plugins( $plugins, self_admin_url( 'plugins.php?error=true' ), is_network_admin() );
if ( ! is_network_admin() ) {
$recent = (array) get_option( 'recently_activated' );
} else {
$recent = (array) get_site_option( 'recently_activated' );
}
foreach ( $plugins as $plugin ) {
unset( $recent[ $plugin ] );
}
if ( ! is_network_admin() ) {
update_option( 'recently_activated', $recent );
} else {
update_site_option( 'recently_activated', $recent );
}
wp_redirect( self_admin_url( "plugins.php?activate-multi=true&plugin_status=$status&paged=$page&s=$s" ) );
exit;
case 'update-selected':
check_admin_referer( 'bulk-plugins' );
if ( isset( $_GET['plugins'] ) ) {
$plugins = explode( ',', wp_unslash( $_GET['plugins'] ) );
} elseif ( isset( $_POST['checked'] ) ) {
$plugins = (array) wp_unslash( $_POST['checked'] );
} else {
$plugins = array();
}
$title = __( 'Update Plugins' );
$parent_file = 'plugins.php';
wp_enqueue_script( 'updates' );
require_once( ABSPATH . 'wp-admin/admin-header.php' );
echo '<div class="wrap">';
echo '<h1>' . esc_html( $title ) . '</h1>';
$url = self_admin_url( 'update.php?action=update-selected&plugins=' . urlencode( join( ',', $plugins ) ) );
$url = wp_nonce_url( $url, 'bulk-update-plugins' );
echo "<iframe src='$url' style='width: 100%; height:100%; min-height:850px;'></iframe>";
echo '</div>';
require_once( ABSPATH . 'wp-admin/admin-footer.php' );
exit;
case 'error_scrape':
if ( ! current_user_can( 'activate_plugin', $plugin ) ) {
wp_die( __( 'Sorry, you are not allowed to activate this plugin.' ) );
}
check_admin_referer( 'plugin-activation-error_' . $plugin );
$valid = validate_plugin( $plugin );
if ( is_wp_error( $valid ) ) {
wp_die( $valid );
}
if ( ! WP_DEBUG ) {
error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );
}
ini_set( 'display_errors', true ); //Ensure that Fatal errors are displayed.
// Go back to "sandbox" scope so we get the same errors as before
plugin_sandbox_scrape( $plugin );
/** This action is documented in wp-admin/includes/plugin.php */
do_action( "activate_{$plugin}" );
exit;
case 'deactivate':
if ( ! current_user_can( 'deactivate_plugin', $plugin ) ) {
wp_die( __( 'Sorry, you are not allowed to deactivate this plugin.' ) );
}
check_admin_referer( 'deactivate-plugin_' . $plugin );
if ( ! is_network_admin() && is_plugin_active_for_network( $plugin ) ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
deactivate_plugins( $plugin, false, is_network_admin() );
if ( ! is_network_admin() ) {
update_option( 'recently_activated', array( $plugin => time() ) + (array) get_option( 'recently_activated' ) );
} else {
update_site_option( 'recently_activated', array( $plugin => time() ) + (array) get_site_option( 'recently_activated' ) );
}
if ( headers_sent() ) {
echo "<meta http-equiv='refresh' content='" . esc_attr( "0;url=plugins.php?deactivate=true&plugin_status=$status&paged=$page&s=$s" ) . "' />";
} else {
wp_redirect( self_admin_url( "plugins.php?deactivate=true&plugin_status=$status&paged=$page&s=$s" ) );
}
exit;
case 'deactivate-selected':
if ( ! current_user_can( 'deactivate_plugins' ) ) {
wp_die( __( 'Sorry, you are not allowed to deactivate plugins for this site.' ) );
}
check_admin_referer( 'bulk-plugins' );
$plugins = isset( $_POST['checked'] ) ? (array) wp_unslash( $_POST['checked'] ) : array();
// Do not deactivate plugins which are already deactivated.
if ( is_network_admin() ) {
$plugins = array_filter( $plugins, 'is_plugin_active_for_network' );
} else {
$plugins = array_filter( $plugins, 'is_plugin_active' );
$plugins = array_diff( $plugins, array_filter( $plugins, 'is_plugin_active_for_network' ) );
foreach ( $plugins as $i => $plugin ) {
// Only deactivate plugins which the user can deactivate.
if ( ! current_user_can( 'deactivate_plugin', $plugin ) ) {
unset( $plugins[ $i ] );
}
}
}
if ( empty( $plugins ) ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
deactivate_plugins( $plugins, false, is_network_admin() );
$deactivated = array();
foreach ( $plugins as $plugin ) {
$deactivated[ $plugin ] = time();
}
if ( ! is_network_admin() ) {
update_option( 'recently_activated', $deactivated + (array) get_option( 'recently_activated' ) );
} else {
update_site_option( 'recently_activated', $deactivated + (array) get_site_option( 'recently_activated' ) );
}
wp_redirect( self_admin_url( "plugins.php?deactivate-multi=true&plugin_status=$status&paged=$page&s=$s" ) );
exit;
case 'delete-selected':
if ( ! current_user_can( 'delete_plugins' ) ) {
wp_die( __( 'Sorry, you are not allowed to delete plugins for this site.' ) );
}
check_admin_referer( 'bulk-plugins' );
//$_POST = from the plugin form; $_GET = from the FTP details screen.
$plugins = isset( $_REQUEST['checked'] ) ? (array) wp_unslash( $_REQUEST['checked'] ) : array();
if ( empty( $plugins ) ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
$plugins = array_filter( $plugins, 'is_plugin_inactive' ); // Do not allow to delete Activated plugins.
if ( empty( $plugins ) ) {
wp_redirect( self_admin_url( "plugins.php?error=true&main=true&plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
// Bail on all if any paths are invalid.
// validate_file() returns truthy for invalid files
$invalid_plugin_files = array_filter( $plugins, 'validate_file' );
if ( $invalid_plugin_files ) {
wp_redirect( self_admin_url( "plugins.php?plugin_status=$status&paged=$page&s=$s" ) );
exit;
}
include( ABSPATH . 'wp-admin/update.php' );
$parent_file = 'plugins.php';
if ( ! isset( $_REQUEST['verify-delete'] ) ) {
wp_enqueue_script( 'jquery' );
require_once( ABSPATH . 'wp-admin/admin-header.php' );
?>
<div class="wrap">
<?php
$plugin_info = array();
$have_non_network_plugins = false;
foreach ( (array) $plugins as $plugin ) {
$plugin_slug = dirname( $plugin );
if ( '.' == $plugin_slug ) {
$data = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin );
if ( $data ) {
$plugin_info[ $plugin ] = $data;
$plugin_info[ $plugin ]['is_uninstallable'] = is_uninstallable_plugin( $plugin );
if ( ! $plugin_info[ $plugin ]['Network'] ) {
$have_non_network_plugins = true;
}
}
} else {
// Get plugins list from that folder.
$folder_plugins = get_plugins( '/' . $plugin_slug );
if ( $folder_plugins ) {
foreach ( $folder_plugins as $plugin_file => $data ) {
$plugin_info[ $plugin_file ] = _get_plugin_data_markup_translate( $plugin_file, $data );
$plugin_info[ $plugin_file ]['is_uninstallable'] = is_uninstallable_plugin( $plugin );
if ( ! $plugin_info[ $plugin_file ]['Network'] ) {
$have_non_network_plugins = true;
}
}
}
}
}
$plugins_to_delete = count( $plugin_info );
?>
<?php if ( 1 == $plugins_to_delete ) : ?>
<h1><?php _e( 'Delete Plugin' ); ?></h1>
<?php if ( $have_non_network_plugins && is_network_admin() ) : ?>
<div class="error"><p><strong><?php _e( 'Caution:' ); ?></strong> <?php _e( 'This plugin may be active on other sites in the network.' ); ?></p></div>
<?php endif; ?>
<p><?php _e( 'You are about to remove the following plugin:' ); ?></p>
<?php else : ?>
<h1><?php _e( 'Delete Plugins' ); ?></h1>
<?php if ( $have_non_network_plugins && is_network_admin() ) : ?>
<div class="error"><p><strong><?php _e( 'Caution:' ); ?></strong> <?php _e( 'These plugins may be active on other sites in the network.' ); ?></p></div>
<?php endif; ?>
<p><?php _e( 'You are about to remove the following plugins:' ); ?></p>
<?php endif; ?>
<ul class="ul-disc">
<?php
$data_to_delete = false;
foreach ( $plugin_info as $plugin ) {
if ( $plugin['is_uninstallable'] ) {
/* translators: 1: Plugin name, 2: Plugin author. */
echo '<li>', sprintf( __( '%1$s by %2$s (will also <strong>delete its data</strong>)' ), '<strong>' . $plugin['Name'] . '</strong>', '<em>' . $plugin['AuthorName'] . '</em>' ), '</li>';
$data_to_delete = true;
} else {
/* translators: 1: Plugin name, 2: Plugin author. */
echo '<li>', sprintf( _x( '%1$s by %2$s', 'plugin' ), '<strong>' . $plugin['Name'] . '</strong>', '<em>' . $plugin['AuthorName'] ) . '</em>', '</li>';
}
}
?>
</ul>
<p>
<?php
if ( $data_to_delete ) {
_e( 'Are you sure you want to delete these files and data?' );
} else {
_e( 'Are you sure you want to delete these files?' );
}
?>
</p>
<form method="post" action="<?php echo esc_url( $_SERVER['REQUEST_URI'] ); ?>" style="display:inline;">
<input type="hidden" name="verify-delete" value="1" />
<input type="hidden" name="action" value="delete-selected" />
<?php
foreach ( (array) $plugins as $plugin ) {
echo '<input type="hidden" name="checked[]" value="' . esc_attr( $plugin ) . '" />';
}
?>
<?php wp_nonce_field( 'bulk-plugins' ); ?>
<?php submit_button( $data_to_delete ? __( 'Yes, delete these files and data' ) : __( 'Yes, delete these files' ), '', 'submit', false ); ?>
</form>
<?php
$referer = wp_get_referer();
?>
<form method="post" action="<?php echo $referer ? esc_url( $referer ) : ''; ?>" style="display:inline;">
<?php submit_button( __( 'No, return me to the plugin list' ), '', 'submit', false ); ?>
</form>
</div>
<?php
require_once( ABSPATH . 'wp-admin/admin-footer.php' );
exit;
} else {
$plugins_to_delete = count( $plugins );
} // endif verify-delete
$delete_result = delete_plugins( $plugins );
set_transient( 'plugins_delete_result_' . $user_ID, $delete_result ); //Store the result in a cache rather than a URL param due to object type & length
wp_redirect( self_admin_url( "plugins.php?deleted=$plugins_to_delete&plugin_status=$status&paged=$page&s=$s" ) );
exit;
case 'clear-recent-list':
if ( ! is_network_admin() ) {
update_option( 'recently_activated', array() );
} else {
update_site_option( 'recently_activated', array() );
}
break;
case 'resume':
if ( is_multisite() ) {
return;
}
if ( ! current_user_can( 'resume_plugin', $plugin ) ) {
wp_die( __( 'Sorry, you are not allowed to resume this plugin.' ) );
}
check_admin_referer( 'resume-plugin_' . $plugin );
$result = resume_plugin( $plugin, self_admin_url( "plugins.php?error=resuming&plugin_status=$status&paged=$page&s=$s" ) );
if ( is_wp_error( $result ) ) {
wp_die( $result );
}
wp_redirect( self_admin_url( "plugins.php?resume=true&plugin_status=$status&paged=$page&s=$s" ) );
exit;
default:
if ( isset( $_POST['checked'] ) ) {
check_admin_referer( 'bulk-plugins' );
$plugins = isset( $_POST['checked'] ) ? (array) wp_unslash( $_POST['checked'] ) : array();
$sendback = wp_get_referer();
/** This action is documented in wp-admin/edit-comments.php */
$sendback = apply_filters( 'handle_bulk_actions-' . get_current_screen()->id, $sendback, $action, $plugins ); // phpcs:ignore WordPress.NamingConventions.ValidHookName.UseUnderscores
wp_safe_redirect( $sendback );
exit;
}
break;
}
}
$wp_list_table->prepare_items();
wp_enqueue_script( 'plugin-install' );
add_thickbox();
add_screen_option( 'per_page', array( 'default' => 999 ) );
get_current_screen()->add_help_tab(
array(
'id' => 'overview',
'title' => __( 'Overview' ),
'content' =>
'<p>' . __( 'Plugins extend and expand the functionality of WordPress. Once a plugin is installed, you may activate it or deactivate it here.' ) . '</p>' .
'<p>' . __( 'The search for installed plugins will search for terms in their name, description, or author.' ) . ' <span id="live-search-desc" class="hide-if-no-js">' . __( 'The search results will be updated as you type.' ) . '</span></p>' .
'<p>' . sprintf(
/* translators: %s: WordPress Plugin Directory URL. */
__( 'If you would like to see more plugins to choose from, click on the “Add New” button and you will be able to browse or search for additional plugins from the <a href="%s">WordPress Plugin Directory</a>. Plugins in the WordPress Plugin Directory are designed and developed by third parties, and are compatible with the license WordPress uses. Oh, and they’re free!' ),
__( 'https://wordpress.org/plugins/' )
) . '</p>',
)
);
get_current_screen()->add_help_tab(
array(
'id' => 'compatibility-problems',
'title' => __( 'Troubleshooting' ),
'content' =>
'<p>' . __( 'Most of the time, plugins play nicely with the core of WordPress and with other plugins. Sometimes, though, a plugin’s code will get in the way of another plugin, causing compatibility issues. If your site starts doing strange things, this may be the problem. Try deactivating all your plugins and re-activating them in various combinations until you isolate which one(s) caused the issue.' ) . '</p>' .
'<p>' . sprintf(
/* translators: WP_PLUGIN_DIR constant value. */
__( 'If something goes wrong with a plugin and you can’t use WordPress, delete or rename that file in the %s directory and it will be automatically deactivated.' ),
'<code>' . WP_PLUGIN_DIR . '</code>'
) . '</p>',
)
);
get_current_screen()->set_help_sidebar(
'<p><strong>' . __( 'For more information:' ) . '</strong></p>' .
'<p>' . __( '<a href="https://wordpress.org/support/article/managing-plugins/">Documentation on Managing Plugins</a>' ) . '</p>' .
'<p>' . __( '<a href="https://wordpress.org/support/">Support</a>' ) . '</p>'
);
get_current_screen()->set_screen_reader_content(
array(
'heading_views' => __( 'Filter plugins list' ),
'heading_pagination' => __( 'Plugins list navigation' ),
'heading_list' => __( 'Plugins list' ),
)
);
$title = __( 'Plugins' );
$parent_file = 'plugins.php';
require_once( ABSPATH . 'wp-admin/admin-header.php' );
$invalid = validate_active_plugins();
if ( ! empty( $invalid ) ) {
foreach ( $invalid as $plugin_file => $error ) {
echo '<div id="message" class="error"><p>';
printf(
/* translators: 1: Plugin file, 2: Error message. */
__( 'The plugin %1$s has been deactivated due to an error: %2$s' ),
'<code>' . esc_html( $plugin_file ) . '</code>',
$error->get_error_message()
);
echo '</p></div>';
}
}
?>
<?php
if ( isset( $_GET['error'] ) ) :
if ( isset( $_GET['main'] ) ) {
$errmsg = __( 'You cannot delete a plugin while it is active on the main site.' );
} elseif ( isset( $_GET['charsout'] ) ) {
$errmsg = sprintf(
/* translators: %d: Number of characters. */
_n(
'The plugin generated %d character of <strong>unexpected output</strong> during activation.',
'The plugin generated %d characters of <strong>unexpected output</strong> during activation.',
$_GET['charsout']
),
$_GET['charsout']
);
$errmsg .= ' ' . __( 'If you notice “headers already sent” messages, problems with syndication feeds or other issues, try deactivating or removing this plugin.' );
} elseif ( 'resuming' === $_GET['error'] ) {
$errmsg = __( 'Plugin could not be resumed because it triggered a <strong>fatal error</strong>.' );
} else {
$errmsg = __( 'Plugin could not be activated because it triggered a <strong>fatal error</strong>.' );
}
?>
<div id="message" class="error"><p><?php echo $errmsg; ?></p>
<?php
if ( ! isset( $_GET['main'] ) && ! isset( $_GET['charsout'] ) && wp_verify_nonce( $_GET['_error_nonce'], 'plugin-activation-error_' . $plugin ) ) {
$iframe_url = add_query_arg(
array(
'action' => 'error_scrape',
'plugin' => urlencode( $plugin ),
'_wpnonce' => urlencode( $_GET['_error_nonce'] ),
),
admin_url( 'plugins.php' )
);
?>
<iframe style="border:0" width="100%" height="70px" src="<?php echo esc_url( $iframe_url ); ?>"></iframe>
<?php
}
?>
</div>
<?php
elseif ( isset( $_GET['deleted'] ) ) :
$delete_result = get_transient( 'plugins_delete_result_' . $user_ID );
// Delete it once we're done.
delete_transient( 'plugins_delete_result_' . $user_ID );
if ( is_wp_error( $delete_result ) ) :
?>
<div id="message" class="error notice is-dismissible">
<p>
<?php
printf(
/* translators: %s: Error message. */
__( 'Plugin could not be deleted due to an error: %s' ),
$delete_result->get_error_message()
);
?>
</p>
</div>
<?php else : ?>
<div id="message" class="updated notice is-dismissible">
<p>
<?php
if ( 1 == (int) $_GET['deleted'] ) {
_e( 'The selected plugin has been deleted.' );
} else {
_e( 'The selected plugins have been deleted.' );
}
?>
</p>
</div>
<?php endif; ?>
<?php elseif ( isset( $_GET['activate'] ) ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'Plugin activated.' ); ?></p></div>
<?php elseif ( isset( $_GET['activate-multi'] ) ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'Selected plugins activated.' ); ?></p></div>
<?php elseif ( isset( $_GET['deactivate'] ) ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'Plugin deactivated.' ); ?></p></div>
<?php elseif ( isset( $_GET['deactivate-multi'] ) ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'Selected plugins deactivated.' ); ?></p></div>
<?php elseif ( 'update-selected' == $action ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'All selected plugins are up to date.' ); ?></p></div>
<?php elseif ( isset( $_GET['resume'] ) ) : ?>
<div id="message" class="updated notice is-dismissible"><p><?php _e( 'Plugin resumed.' ); ?></p></div>
<?php endif; ?>
<div class="wrap">
<h1 class="wp-heading-inline">
<?php
echo esc_html( $title );
?>
</h1>
<?php
if ( ( ! is_multisite() || is_network_admin() ) && current_user_can( 'install_plugins' ) ) {
?>
<a href="<?php echo self_admin_url( 'plugin-install.php' ); ?>" class="page-title-action"><?php echo esc_html_x( 'Add New', 'plugin' ); ?></a>
<?php
}
if ( strlen( $s ) ) {
/* translators: %s: Search query. */
printf( '<span class="subtitle">' . __( 'Search results for “%s”' ) . '</span>', esc_html( urldecode( $s ) ) );
}
?>
<hr class="wp-header-end">
<?php
/**
* Fires before the plugins list table is rendered.
*
* This hook also fires before the plugins list table is rendered in the Network Admin.
*
* Please note: The 'active' portion of the hook name does not refer to whether the current
* view is for active plugins, but rather all plugins actively-installed.
*
* @since 3.0.0
*
* @param array[] $plugins_all An array of arrays containing information on all installed plugins.
*/
do_action( 'pre_current_active_plugins', $plugins['all'] );
?>
<?php $wp_list_table->views(); ?>
<form class="search-form search-plugins" method="get">
<?php $wp_list_table->search_box( __( 'Search Installed Plugins' ), 'plugin' ); ?>
</form>
<form method="post" id="bulk-action-form">
<input type="hidden" name="plugin_status" value="<?php echo esc_attr( $status ); ?>" />
<input type="hidden" name="paged" value="<?php echo esc_attr( $page ); ?>" />
<?php $wp_list_table->display(); ?>
</form>
<span class="spinner"></span>
</div>
<?php
wp_print_request_filesystem_credentials_modal();
wp_print_admin_notice_templates();
wp_print_update_row_templates();
include( ABSPATH . 'wp-admin/admin-footer.php' );
| gpl-2.0 |
cgb37/umlib-wp.local | wp-content/plugins/types/embedded/classes/relationship.php | 16640 | <?php
/*
* Post relationship class.
*
* $HeadURL: http://plugins.svn.wordpress.org/types/tags/1.6.5.1/embedded/classes/relationship.php $
* $LastChangedDate: 2015-01-16 14:28:15 +0000 (Fri, 16 Jan 2015) $
* $LastChangedRevision: 1069430 $
* $LastChangedBy: iworks $
*
*/
/**
* Post relationship class
*
* @since Types 1.2
* @package Types
* @subpackage Classes
* @version 0.1
* @category Relationship
* @author srdjan <[email protected]>
*
*/
class WPCF_Relationship
{
/**
* Custom field
*
* @var type
*/
var $cf = array();
var $data = array();
/**
* Settings
*
* @var type
*/
var $settings = array();
var $items_per_page = 5;
var $items_per_page_option_name = '_wpcf_relationship_items_per_page';
var $child_form = null;
/**
* Construct function.
*/
function __construct()
{
$this->cf = new WPCF_Field;
$this->settings = get_option( 'wpcf_post_relationship', array() );
add_action( 'wp_ajax_add-types_reltax_add',
array($this, 'ajaxAddTax') );
}
/**
* Sets current data.
*
* @param type $parent
* @param type $child
* @param type $field
* @param type $data
*/
function set( $parent, $child, $data = array() )
{
return $this->_set( $parent, $child, $data );
}
/**
* Sets current data.
*
* @param type $parent
* @param type $child
* @param type $field
* @param type $data
*/
function _set( $parent, $child, $data = array() )
{
$this->parent = $parent;
$this->child = $child;
$this->cf = new WPCF_Field;
// TODO Revise usage
$this->data = $data;
}
/**
* Meta box form on post edit page.
*
* @param type $parent Parent post
* @param type $post_type Child post type
* @return type string HTML formatted form table
*/
function child_meta_form($parent, $post_type)
{
if ( is_integer( $parent ) ) {
$parent = get_post( $parent );
}
$output = '';
require_once dirname( __FILE__ ) . '/relationship/form-child.php';
$this->child_form = new WPCF_Relationship_Child_Form(
$parent,
$post_type,
$this->settings( $parent->post_type, $post_type )
);
$output .= $this->child_form->render();
return $output;
}
/**
* Child row rendered on AJAX 'Add New Child' call.
*
* @param type $parent_id
* @param type $child_id
* @return type
*/
function child_row($parent_id, $child_id)
{
$parent = get_post( intval( $parent_id ) );
$child = get_post( intval( $child_id ) );
if ( empty( $parent ) || empty( $child ) ) {
return new WP_Error( 'wpcf-relationship-save-child', 'no parent/child post' );
}
$output = '';
$this->child_form = $this->_get_child_form( $parent, $child );
$output .= $this->child_form->child_row( $child );
return $output;
}
/**
* Returns HTML formatted form.
*
* @param type $parent
* @param type $child
* @return \WPCF_Relationship_Child_Form
*/
function _get_child_form($parent, $child)
{
require_once dirname( __FILE__ ) . '/relationship/form-child.php';
return new WPCF_Relationship_Child_Form(
$parent,
$child->post_type,
$this->settings( $parent->post_type, $child->post_type )
);
}
function get_child()
{
$r = $this->child;
$r->parent = $this->parent;
$r->form = $this->_get_child_form( $r->parent, $this->child );
return $r;
}
/**
* Save items_per_page settings.
*
* @param type $parent
* @param type $child
* @param int $num
*/
function save_items_per_page($parent, $child, $num)
{
if ( post_type_exists( $parent ) && post_type_exists( $child ) ) {
$option_name = $this->items_per_page_option_name . '_' . $parent . '_' . $child;
if ( $num == 'all' ) {
$num = 9999999999999999;
}
update_option( $option_name, intval( $num ) );
}
}
/**
* Return items_per_page settings
*
* @param type $parent
* @param type $child
* @return type
*/
function get_items_per_page($parent, $child)
{
$per_page = get_option( $this->items_per_page_option_name . '_' . $parent . '_' . $child,
$this->items_per_page );
return empty( $per_page ) ? $this->items_per_page : $per_page;
}
/**
* Adjusts post name when saving.
*
* @todo Revise (not used?)
* @param type $post
* @return type
*/
function get_insert_post_name($post)
{
if ( empty( $post->post_title ) ) {
return $post->post_type . '-' . $post->ID;
}
return $post->post_title;
}
/**
* Bulk saving children.
*
* @param type $parent_id
* @param type $children
*/
function save_children($parent_id, $children)
{
foreach ( $children as $child_id => $fields ) {
$this->save_child( $parent_id, $child_id, $fields );
}
}
/**
* Unified save child function.
*
* @param type $child_id
* @param type $parent_id
*/
function save_child( $parent_id, $child_id, $save_fields = array() )
{
global $wpdb;
$parent = get_post( intval( $parent_id ) );
$child = get_post( intval( $child_id ) );
$post_data = array();
if ( empty( $parent ) || empty( $child ) ) {
return new WP_Error( 'wpcf-relationship-save-child', 'no parent/child post' );
}
// Save relationship
update_post_meta( $child->ID,
'_wpcf_belongs_' . $parent->post_type . '_id', $parent->ID );
// Check if added via AJAX
$check = get_post_meta( $child->ID, '_wpcf_relationship_new', true );
$new = !empty( $check );
delete_post_meta( $child->ID, '_wpcf_relationship_new' );
// Set post data
$post_data['ID'] = $child->ID;
// Title needs to be checked if submitted at all
if ( !isset( $save_fields['_wp_title'] ) ) {
// If not submitted that means it is not offered to be edited
if ( !empty( $child->post_title ) ) {
$post_title = $child->post_title;
} else {
// DO NOT LET IT BE EMPTY
$post_title = $child->post_type . ' ' . $child->ID;
}
} else {
$post_title = $save_fields['_wp_title'];
}
$post_data['post_title'] = $post_title;
$post_data['post_content'] = isset( $save_fields['_wp_body'] ) ? $save_fields['_wp_body'] : $child->post_content;
$post_data['post_type'] = $child->post_type;
// Check post status - if new, convert to 'publish' else keep remaining
if ( $new ) {
$post_data['post_status'] = 'publish';
} else {
$post_data['post_status'] = get_post_status( $child->ID );
}
/*
*
*
*
*
*
*
* UPDATE POST
*/
$cf = new WPCF_Field;
if (
isset( $_POST['wpcf_post_relationship'][$parent_id])
&& isset( $_POST['wpcf_post_relationship'][$parent_id][$child_id] )
) {
$_POST['wpcf'] = array();
foreach( $_POST['wpcf_post_relationship'][$parent_id][$child_id] as $slug => $value ) {
$_POST['wpcf'][$cf->__get_slug_no_prefix( $slug )] = $value;
$_POST['wpcf'][$slug] = $value;
}
}
unset($cf);
$updated_id = wp_update_post( $post_data );
if ( empty( $updated_id ) ) {
return new WP_Error( 'relationship-update-post-failed', 'Updating post failed' );
}
// Save parents
if ( !empty( $save_fields['parents'] ) ) {
foreach ( $save_fields['parents'] as $parent_post_type => $parent_post_id ) {
update_post_meta( $child->ID,
'_wpcf_belongs_' . $parent_post_type . '_id',
$parent_post_id );
}
}
// Update taxonomies
if ( !empty( $save_fields['taxonomies'] ) && is_array( $save_fields['taxonomies'] ) ) {
$_save_data = array();
foreach ( $save_fields['taxonomies'] as $taxonomy => $t ) {
if ( !is_taxonomy_hierarchical( $taxonomy ) ) {
$_save_data[$taxonomy] = strval( $t );
continue;
}
foreach ( $t as $term_id ) {
if ( $term_id != '-1' ) {
$term = get_term( $term_id, $taxonomy );
if ( empty( $term ) ) {
continue;
}
$_save_data[$taxonomy][] = $term_id;
}
}
}
wp_delete_object_term_relationships( $child->ID,
array_keys( $save_fields['taxonomies'] ) );
foreach ( $_save_data as $_taxonomy => $_terms ) {
wp_set_post_terms( $child->ID, $_terms, $_taxonomy,
$append = false );
}
}
// Unset non-types
unset( $save_fields['_wp_title'], $save_fields['_wp_body'],
$save_fields['parents'], $save_fields['taxonomies'] );
/*
*
*
*
*
*
*
* UPDATE Loop over fields
*/
foreach ( $save_fields as $slug => $value ) {
if ( defined( 'WPTOOLSET_FORMS_VERSION' ) ) {
// Get field by slug
$field = wpcf_fields_get_field_by_slug( str_replace( WPCF_META_PREFIX,
'', $slug ) );
if ( empty( $field ) ) {
continue;
}
// Set config
$config = wptoolset_form_filter_types_field( $field, $child->ID );
// Check if valid
$valid = wptoolset_form_validate_field( 'post', $config, $value );
if ( is_wp_error( $valid ) ) {
$errors = $valid->get_error_data();
$msg = sprintf( __( 'Child post "%s" field "%s" not updated:',
'wpcf' ), $child->post_title, $field['name'] );
wpcf_admin_message_store( $msg . ' ' . implode( ', ',
$errors ), 'error' );
continue;
}
}
$this->cf->set( $child, $field );
$this->cf->context = 'post_relationship';
$this->cf->save( $value );
}
do_action( 'wpcf_relationship_save_child', $child, $parent );
clean_post_cache( $parent->ID );
clean_post_cache( $child->ID );
// Added because of caching meta 1.5.4
wp_cache_flush();
return true;
}
/**
* Saves new child.
*
* @param type $parent_id
* @param type $post_type
* @return type
*/
function add_new_child($parent_id, $post_type)
{
global $wpdb;
$parent = get_post( $parent_id );
if ( empty( $parent ) ) {
return new WP_Error( 'wpcf-relationship-no-parent', 'No parent' );
}
$new_post = array(
'post_title' => __('New'). ': '.$post_type,
'post_type' => $post_type,
'post_status' => 'draft',
);
$id = wp_insert_post( $new_post, true );
/**
* return wp_error
*/
if ( is_wp_error( $id ) ) {
return $id;
}
/**
* Mark that it is new post
*/
update_post_meta( $id, '_wpcf_relationship_new', 1 );
/**
* Save relationship
*/
update_post_meta( $id, '_wpcf_belongs_' . $parent->post_type . '_id', $parent->ID );
/**
* Fix title
*/
$wpdb->update(
$wpdb->posts,
array('post_title' => $post_type . ' ' . $id),
array('ID' => $id), array('%s'), array('%d')
);
do_action( 'wpcf_relationship_add_child', get_post( $id ), $parent );
wp_cache_flush();
return $id;
}
/**
* Saved relationship settings.
*
* @param type $parent
* @param type $child
* @return type
*/
function settings($parent, $child)
{
return isset( $this->settings[$parent][$child] ) ? $this->settings[$parent][$child] : array();
}
/**
* Fetches submitted data.
*
* @param type $parent_id
* @param type $child_id
* @return type
*/
function get_submitted_data($parent_id, $child_id, $field)
{
if ( !is_string( $field ) ) {
$_field_slug = $field->slug;
} else {
$_field_slug = $field;
}
return isset( $_POST['wpcf_post_relationship'][$parent_id][$child_id][$_field_slug] ) ? $_POST['wpcf_post_relationship'][$parent_id][$child_id][$_field_slug] : null;
}
/**
* Gets all parents per post type.
*
* @param type $child
* @return type
*/
public static function get_parents($child)
{
$parents = array();
$item_parents = wpcf_pr_admin_get_belongs( $child->post_type );
if ( $item_parents ) {
foreach ( $item_parents as $post_type => $data ) {
// Get parent ID
$meta = wpcf_get_post_meta( $child->ID,
'_wpcf_belongs_' . $post_type . '_id', true );
if ( !empty( $meta ) ) {
$parent_post = get_post( $meta );
if ( !empty( $parent_post ) ) {
$parents[$parent_post->post_type] = $parent_post;
}
}
}
}
return $parents;
}
/**
* Gets post parent by post type.
*
* @param type $post_id
* @param type $parent_post_type
* @return type
*/
public static function get_parent($post_id, $parent_post_type)
{
return wpcf_get_post_meta( $post_id,
'_wpcf_belongs_' . $parent_post_type . '_id', true );
}
/**
* AJAX adding taxonomies
*/
public function ajaxAddTax()
{
if ( isset( $_POST['types_reltax'] ) ) {
$data = array_shift( $_POST['types_reltax'] );
$tax = key( $data );
$val = array_shift( $data );
$__nonce = array_shift( $_POST['types_reltax_nonce'] );
$nonce = array_shift( $__nonce );
$_POST['action'] = 'add-' . $tax;
$_POST['post_category'][$tax] = $val;
$_POST['tax_input'][$tax] = $val;
$_POST['new'.$tax] = $val;
$_REQUEST["_ajax_nonce-add-{$tax}"] = $nonce;
_wp_ajax_add_hierarchical_term();
}
die();
}
/**
* Meta box form on post edit page.
*
* @param type $parent Parent post
* @param type $post_type Child post type
* @return type string HTML formatted list
*/
function child_list($parent, $post_type)
{
if ( is_integer( $parent ) ) {
$parent = get_post( $parent );
}
$output = '';
require_once dirname( __FILE__ ) . '/relationship/form-child.php';
$this->child_form = new WPCF_Relationship_Child_Form(
$parent,
$post_type,
$this->settings( $parent->post_type, $post_type )
);
foreach($this->child_form->children as $child) {
$output .= sprintf(
'<li>%s</li>',
apply_filters('post_title', $child->post_title)
);
}
if ( $output ) {
$output = sprintf(
'<ul>%s</ul>',
$output
);
} else {
$output = sprintf(
'<p class="info">%s</p>',
$this->child_form->child_post_type_object->labels->not_found
);
}
return $output;
}
}
| gpl-2.0 |
stfn-jcb/client | test/testsyncjournaldb.h | 2895 | /*
* This software is in the public domain, furnished "as is", without technical
* support, and with no warranty, express or implied, as to its usefulness for
* any purpose.
* */
#ifndef MIRALL_TESTSYNCJOURNALDB_H
#define MIRALL_TESTSYNCJOURNALDB_H
#include <QtTest>
#include <sqlite3.h>
#include "libsync/syncjournaldb.h"
#include "libsync/syncjournalfilerecord.h"
using namespace OCC;
namespace {
const char testdbC[] = "/tmp";
}
class TestSyncJournalDB : public QObject
{
Q_OBJECT
public:
TestSyncJournalDB()
: _db(testdbC)
{
}
QDateTime dropMsecs(QDateTime time)
{
return Utility::qDateTimeFromTime_t(Utility::qDateTimeToTime_t(time));
}
private slots:
void initTestCase()
{
}
void cleanupTestCase()
{
}
void testFileRecord()
{
SyncJournalFileRecord record = _db.getFileRecord("nonexistant");
QVERIFY(!record.isValid());
record._path = "foo";
record._inode = 1234;
record._modtime = dropMsecs(QDateTime::currentDateTime());
record._type = 5;
record._etag = "789789";
record._fileId = "abcd";
record._remotePerm = "744";
record._mode = -17;
record._fileSize = 213089055;
QVERIFY(_db.setFileRecord(record));
SyncJournalFileRecord storedRecord = _db.getFileRecord("foo");
QVERIFY(storedRecord == record);
QVERIFY(_db.deleteFileRecord("foo"));
record = _db.getFileRecord("foo");
QVERIFY(!record.isValid());
}
void testDownloadInfo()
{
typedef SyncJournalDb::DownloadInfo Info;
Info record = _db.getDownloadInfo("nonexistant");
QVERIFY(!record._valid);
record._errorCount = 5;
record._etag = "ABCDEF";
record._valid = true;
record._tmpfile = "/tmp/foo";
_db.setDownloadInfo("foo", record);
Info storedRecord = _db.getDownloadInfo("foo");
QVERIFY(storedRecord == record);
_db.setDownloadInfo("foo", Info());
Info wipedRecord = _db.getDownloadInfo("foo");
QVERIFY(!wipedRecord._valid);
}
void testUploadInfo()
{
typedef SyncJournalDb::UploadInfo Info;
Info record = _db.getUploadInfo("nonexistant");
QVERIFY(!record._valid);
record._errorCount = 5;
record._chunk = 12;
record._transferid = 812974891;
record._size = 12894789147;
record._modtime = dropMsecs(QDateTime::currentDateTime());
record._valid = true;
_db.setUploadInfo("foo", record);
Info storedRecord = _db.getUploadInfo("foo");
QVERIFY(storedRecord == record);
_db.setUploadInfo("foo", Info());
Info wipedRecord = _db.getUploadInfo("foo");
QVERIFY(!wipedRecord._valid);
}
private:
SyncJournalDb _db;
};
#endif
| gpl-2.0 |
md-5/jdk10 | src/java.base/share/classes/sun/util/locale/provider/DateFormatProviderImpl.java | 7634 | /*
* Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.util.locale.provider;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.text.spi.DateFormatProvider;
import java.util.Calendar;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.Set;
import java.util.TimeZone;
/**
* Concrete implementation of the {@link java.text.spi.DateFormatProvider
* DateFormatProvider} class for the JRE LocaleProviderAdapter.
*
* @author Naoto Sato
* @author Masayoshi Okutsu
*/
public class DateFormatProviderImpl extends DateFormatProvider implements AvailableLanguageTags {
private final LocaleProviderAdapter.Type type;
private final Set<String> langtags;
public DateFormatProviderImpl(LocaleProviderAdapter.Type type, Set<String> langtags) {
this.type = type;
this.langtags = langtags;
}
/**
* Returns an array of all locales for which this locale service provider
* can provide localized objects or names.
*
* @return An array of all locales for which this locale service provider
* can provide localized objects or names.
*/
@Override
public Locale[] getAvailableLocales() {
return LocaleProviderAdapter.toLocaleArray(langtags);
}
@Override
public boolean isSupportedLocale(Locale locale) {
return LocaleProviderAdapter.forType(type).isSupportedProviderLocale(locale, langtags);
}
/**
* Returns a new <code>DateFormat</code> instance which formats time
* with the given formatting style for the specified locale.
* @param style the given formatting style. Either one of
* {@link java.text.DateFormat#SHORT DateFormat.SHORT},
* {@link java.text.DateFormat#MEDIUM DateFormat.MEDIUM},
* {@link java.text.DateFormat#LONG DateFormat.LONG}, or
* {@link java.text.DateFormat#FULL DateFormat.FULL}.
* @param locale the desired locale.
* @exception IllegalArgumentException if <code>style</code> is invalid,
* or if <code>locale</code> isn't
* one of the locales returned from
* {@link java.util.spi.LocaleServiceProvider#getAvailableLocales()
* getAvailableLocales()}.
* @exception NullPointerException if <code>locale</code> is null
* @return a time formatter.
* @see java.text.DateFormat#getTimeInstance(int, java.util.Locale)
*/
@Override
public DateFormat getTimeInstance(int style, Locale locale) {
return getInstance(-1, style, locale);
}
/**
* Returns a new <code>DateFormat</code> instance which formats date
* with the given formatting style for the specified locale.
* @param style the given formatting style. Either one of
* {@link java.text.DateFormat#SHORT DateFormat.SHORT},
* {@link java.text.DateFormat#MEDIUM DateFormat.MEDIUM},
* {@link java.text.DateFormat#LONG DateFormat.LONG}, or
* {@link java.text.DateFormat#FULL DateFormat.FULL}.
* @param locale the desired locale.
* @exception IllegalArgumentException if <code>style</code> is invalid,
* or if <code>locale</code> isn't
* one of the locales returned from
* {@link java.util.spi.LocaleServiceProvider#getAvailableLocales()
* getAvailableLocales()}.
* @exception NullPointerException if <code>locale</code> is null
* @return a date formatter.
* @see java.text.DateFormat#getDateInstance(int, java.util.Locale)
*/
@Override
public DateFormat getDateInstance(int style, Locale locale) {
return getInstance(style, -1, locale);
}
/**
* Returns a new <code>DateFormat</code> instance which formats date and time
* with the given formatting style for the specified locale.
* @param dateStyle the given date formatting style. Either one of
* {@link java.text.DateFormat#SHORT DateFormat.SHORT},
* {@link java.text.DateFormat#MEDIUM DateFormat.MEDIUM},
* {@link java.text.DateFormat#LONG DateFormat.LONG}, or
* {@link java.text.DateFormat#FULL DateFormat.FULL}.
* @param timeStyle the given time formatting style. Either one of
* {@link java.text.DateFormat#SHORT DateFormat.SHORT},
* {@link java.text.DateFormat#MEDIUM DateFormat.MEDIUM},
* {@link java.text.DateFormat#LONG DateFormat.LONG}, or
* {@link java.text.DateFormat#FULL DateFormat.FULL}.
* @param locale the desired locale.
* @exception IllegalArgumentException if <code>dateStyle</code> or
* <code>timeStyle</code> is invalid,
* or if <code>locale</code> isn't
* one of the locales returned from
* {@link java.util.spi.LocaleServiceProvider#getAvailableLocales()
* getAvailableLocales()}.
* @exception NullPointerException if <code>locale</code> is null
* @return a date/time formatter.
* @see java.text.DateFormat#getDateTimeInstance(int, int, java.util.Locale)
*/
@Override
public DateFormat getDateTimeInstance(int dateStyle, int timeStyle,
Locale locale) {
return getInstance(dateStyle, timeStyle, locale);
}
private DateFormat getInstance(int dateStyle, int timeStyle, Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
// Check for region override
Locale rg = CalendarDataUtility.findRegionOverride(locale);
SimpleDateFormat sdf = new SimpleDateFormat("", rg);
Calendar cal = sdf.getCalendar();
try {
String pattern = LocaleProviderAdapter.forType(type)
.getLocaleResources(rg).getDateTimePattern(timeStyle, dateStyle,
cal);
sdf.applyPattern(pattern);
} catch (MissingResourceException mre) {
// Specify the fallback pattern
sdf.applyPattern("M/d/yy h:mm a");
}
// Check for timezone override
String tz = locale.getUnicodeLocaleType("tz");
if (tz != null) {
sdf.setTimeZone(
TimeZoneNameUtility.convertLDMLShortID(tz)
.map(TimeZone::getTimeZone)
.orElseGet(sdf::getTimeZone));
}
return sdf;
}
@Override
public Set<String> getAvailableLanguageTags() {
return langtags;
}
}
| gpl-2.0 |
freak97/binutils | include/coff/m68k.h | 2660 | /* coff information for M68K
Copyright (C) 2001-2016 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#ifndef GNU_COFF_M68K_H
#define GNU_COFF_M68K_H 1
#define L_LNNO_SIZE 2
#include "coff/external.h"
/* Motorola 68000/68008/68010/68020 */
#define MC68MAGIC 0520
#define MC68KWRMAGIC 0520 /* writeable text segments */
#define MC68TVMAGIC 0521
#define MC68KROMAGIC 0521 /* readonly shareable text segments */
#define MC68KPGMAGIC 0522 /* demand paged text segments */
#define M68MAGIC 0210
#define M68TVMAGIC 0211
/* This is the magic of the Bull dpx/2 */
#define MC68KBCSMAGIC 0526
/* This is Lynx's all-platform magic number for executables. */
#define LYNXCOFFMAGIC 0415
#define OMAGIC M68MAGIC
/* This intentionally does not include MC68KBCSMAGIC; it only includes
magic numbers which imply that names do not have underscores. */
#define M68KBADMAG(x) (((x).f_magic != MC68MAGIC) \
&& ((x).f_magic != MC68KWRMAGIC) \
&& ((x).f_magic != MC68TVMAGIC) \
&& ((x).f_magic != MC68KROMAGIC) \
&& ((x).f_magic != MC68KPGMAGIC) \
&& ((x).f_magic != M68MAGIC) \
&& ((x).f_magic != M68TVMAGIC) \
&& ((x).f_magic != LYNXCOFFMAGIC))
/* Magic numbers for the a.out header. */
#define PAGEMAGICEXECSWAPPED 0407 /* executable (swapped) */
#define PAGEMAGICPEXECSWAPPED 0410 /* pure executable (swapped) */
#define PAGEMAGICPEXECTSHLIB 0443 /* pure executable (target shared library) */
#define PAGEMAGICPEXECPAGED 0413 /* pure executable (paged) */
/********************** RELOCATION DIRECTIVES **********************/
struct external_reloc
{
char r_vaddr[4];
char r_symndx[4];
char r_type[2];
#ifdef M68K_COFF_OFFSET
char r_offset[4];
#endif
};
#define RELOC struct external_reloc
#ifdef M68K_COFF_OFFSET
#define RELSZ 14
#else
#define RELSZ 10
#endif
#endif /* GNU_COFF_M68K_H */
| gpl-2.0 |
vkrmsngh/new_pro | u-boot/include/configs/tegra-common-post.h | 4803 | /*
* (C) Copyright 2010-2012
* NVIDIA Corporation <www.nvidia.com>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef __TEGRA_COMMON_POST_H
#define __TEGRA_COMMON_POST_H
#ifdef CONFIG_BOOTCOMMAND
#define BOOTCMDS_COMMON ""
#else
#ifdef CONFIG_CMD_MMC
#define BOOTCMDS_MMC \
"mmc_boot=" \
"setenv devtype mmc; " \
"if mmc dev ${devnum}; then " \
"run scan_boot; " \
"fi\0" \
"bootcmd_mmc0=setenv devnum 0; run mmc_boot;\0" \
"bootcmd_mmc1=setenv devnum 1; run mmc_boot;\0"
#define BOOT_TARGETS_MMC "mmc1 mmc0"
#else
#define BOOTCMDS_MMC ""
#define BOOT_TARGETS_MMC ""
#endif
#ifdef CONFIG_CMD_USB
#define BOOTCMD_INIT_USB "run usb_init; "
#define BOOTCMDS_USB \
"usb_init=" \
"if ${usb_need_init}; then " \
"set usb_need_init false; " \
"usb start 0; " \
"fi\0" \
\
"usb_boot=" \
"setenv devtype usb; " \
BOOTCMD_INIT_USB \
"if usb dev ${devnum}; then " \
"run scan_boot; " \
"fi\0" \
\
"bootcmd_usb0=setenv devnum 0; run usb_boot;\0"
#define BOOT_TARGETS_USB "usb0"
#else
#define BOOTCMD_INIT_USB ""
#define BOOTCMDS_USB ""
#define BOOT_TARGETS_USB ""
#endif
#ifdef CONFIG_CMD_DHCP
#define BOOTCMDS_DHCP \
"bootcmd_dhcp=" \
BOOTCMD_INIT_USB \
"if dhcp ${scriptaddr} boot.scr.uimg; then "\
"source ${scriptaddr}; " \
"fi\0"
#define BOOT_TARGETS_DHCP "dhcp"
#else
#define BOOTCMDS_DHCP ""
#define BOOT_TARGETS_DHCP ""
#endif
#define BOOTCMDS_COMMON \
"rootpart=1\0" \
\
"script_boot=" \
"if load ${devtype} ${devnum}:${rootpart} " \
"${scriptaddr} ${prefix}${script}; then " \
"echo ${script} found! Executing ...;" \
"source ${scriptaddr};" \
"fi;\0" \
\
"scan_boot=" \
"echo Scanning ${devtype} ${devnum}...; " \
"for prefix in ${boot_prefixes}; do " \
"for script in ${boot_scripts}; do " \
"run script_boot; " \
"done; " \
"done;\0" \
\
"boot_targets=" \
BOOT_TARGETS_MMC " " \
BOOT_TARGETS_USB " " \
BOOT_TARGETS_DHCP " " \
"\0" \
\
"boot_prefixes=/ /boot/\0" \
\
"boot_scripts=boot.scr.uimg boot.scr\0" \
\
BOOTCMDS_MMC \
BOOTCMDS_USB \
BOOTCMDS_DHCP
#define CONFIG_BOOTCOMMAND \
"for target in ${boot_targets}; do run bootcmd_${target}; done"
#endif
#ifdef CONFIG_TEGRA_KEYBOARD
#define STDIN_KBD_KBC ",tegra-kbc"
#else
#define STDIN_KBD_KBC ""
#endif
#ifdef CONFIG_USB_KEYBOARD
#define STDIN_KBD_USB ",usbkbd"
#define CONFIG_SYS_USB_EVENT_POLL
#define CONFIG_PREBOOT "usb start"
#else
#define STDIN_KBD_USB ""
#endif
#ifdef CONFIG_VIDEO_TEGRA
#define STDOUT_LCD ",lcd"
#else
#define STDOUT_LCD ""
#endif
#define TEGRA_DEVICE_SETTINGS \
"stdin=serial" STDIN_KBD_KBC STDIN_KBD_USB "\0" \
"stdout=serial" STDOUT_LCD "\0" \
"stderr=serial" STDOUT_LCD "\0" \
""
#define CONFIG_EXTRA_ENV_SETTINGS \
TEGRA_DEVICE_SETTINGS \
MEM_LAYOUT_ENV_SETTINGS \
BOOTCMDS_COMMON
#if defined(CONFIG_TEGRA20_SFLASH) || defined(CONFIG_TEGRA20_SLINK) || defined(CONFIG_TEGRA114_SPI)
#define CONFIG_FDT_SPI
#endif
/* overrides for SPL build here */
#ifdef CONFIG_SPL_BUILD
#define CONFIG_SKIP_LOWLEVEL_INIT
/* remove devicetree support */
#ifdef CONFIG_OF_CONTROL
#undef CONFIG_OF_CONTROL
#endif
/* remove I2C support */
#ifdef CONFIG_SYS_I2C_TEGRA
#undef CONFIG_SYS_I2C_TEGRA
#endif
#ifdef CONFIG_CMD_I2C
#undef CONFIG_CMD_I2C
#endif
/* remove MMC support */
#ifdef CONFIG_MMC
#undef CONFIG_MMC
#endif
#ifdef CONFIG_GENERIC_MMC
#undef CONFIG_GENERIC_MMC
#endif
#ifdef CONFIG_TEGRA_MMC
#undef CONFIG_TEGRA_MMC
#endif
#ifdef CONFIG_CMD_MMC
#undef CONFIG_CMD_MMC
#endif
/* remove partitions/filesystems */
#ifdef CONFIG_DOS_PARTITION
#undef CONFIG_DOS_PARTITION
#endif
#ifdef CONFIG_EFI_PARTITION
#undef CONFIG_EFI_PARTITION
#endif
#ifdef CONFIG_CMD_FS_GENERIC
#undef CONFIG_CMD_FS_GENERIC
#endif
#ifdef CONFIG_CMD_EXT4
#undef CONFIG_CMD_EXT4
#endif
#ifdef CONFIG_CMD_EXT2
#undef CONFIG_CMD_EXT2
#endif
#ifdef CONFIG_CMD_FAT
#undef CONFIG_CMD_FAT
#endif
#ifdef CONFIG_FS_EXT4
#undef CONFIG_FS_EXT4
#endif
#ifdef CONFIG_FS_FAT
#undef CONFIG_FS_FAT
#endif
/* remove USB */
#ifdef CONFIG_USB_EHCI
#undef CONFIG_USB_EHCI
#endif
#ifdef CONFIG_USB_EHCI_TEGRA
#undef CONFIG_USB_EHCI_TEGRA
#endif
#ifdef CONFIG_USB_STORAGE
#undef CONFIG_USB_STORAGE
#endif
#ifdef CONFIG_CMD_USB
#undef CONFIG_CMD_USB
#endif
/* remove part command support */
#ifdef CONFIG_PARTITION_UUIDS
#undef CONFIG_PARTITION_UUIDS
#endif
#ifdef CONFIG_CMD_PART
#undef CONFIG_CMD_PART
#endif
#endif /* CONFIG_SPL_BUILD */
#endif /* __TEGRA_COMMON_POST_H */
| gpl-2.0 |
brunotougeiro/python | venv/Include/pyerrors.h | 17237 | #ifndef Py_ERRORS_H
#define Py_ERRORS_H
#ifdef __cplusplus
extern "C" {
#endif
/* Error objects */
#ifndef Py_LIMITED_API
/* PyException_HEAD defines the initial segment of every exception class. */
#define PyException_HEAD PyObject_HEAD PyObject *dict;\
PyObject *args; PyObject *traceback;\
PyObject *context; PyObject *cause;\
char suppress_context;
typedef struct {
PyException_HEAD
} PyBaseExceptionObject;
typedef struct {
PyException_HEAD
PyObject *msg;
PyObject *filename;
PyObject *lineno;
PyObject *offset;
PyObject *text;
PyObject *print_file_and_line;
} PySyntaxErrorObject;
typedef struct {
PyException_HEAD
PyObject *msg;
PyObject *name;
PyObject *path;
} PyImportErrorObject;
typedef struct {
PyException_HEAD
PyObject *encoding;
PyObject *object;
Py_ssize_t start;
Py_ssize_t end;
PyObject *reason;
} PyUnicodeErrorObject;
typedef struct {
PyException_HEAD
PyObject *code;
} PySystemExitObject;
typedef struct {
PyException_HEAD
PyObject *myerrno;
PyObject *strerror;
PyObject *filename;
PyObject *filename2;
#ifdef MS_WINDOWS
PyObject *winerror;
#endif
Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */
} PyOSErrorObject;
typedef struct {
PyException_HEAD
PyObject *value;
} PyStopIterationObject;
/* Compatibility typedefs */
typedef PyOSErrorObject PyEnvironmentErrorObject;
#ifdef MS_WINDOWS
typedef PyOSErrorObject PyWindowsErrorObject;
#endif
#endif /* !Py_LIMITED_API */
/* Error handling definitions */
PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *);
#endif
PyAPI_FUNC(void) PyErr_SetString(
PyObject *exception,
const char *string /* decoded from utf-8 */
);
PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
PyAPI_FUNC(void) PyErr_Clear(void);
PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **);
PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *);
#endif
#if defined(__clang__) || \
(defined(__GNUC_MAJOR__) && \
((__GNUC_MAJOR__ >= 3) || \
(__GNUC_MAJOR__ == 2) && (__GNUC_MINOR__ >= 5)))
#define _Py_NO_RETURN __attribute__((__noreturn__))
#else
#define _Py_NO_RETURN
#endif
/* Defined in Python/pylifecycle.c */
PyAPI_FUNC(void) Py_FatalError(const char *message) _Py_NO_RETURN;
#if defined(Py_DEBUG) || defined(Py_LIMITED_API)
#define _PyErr_OCCURRED() PyErr_Occurred()
#else
#define _PyErr_OCCURRED() (PyThreadState_GET()->curexc_type)
#endif
/* Error testing and normalization */
PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);
PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
/* Traceback manipulation (PEP 3134) */
PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *);
PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *);
/* Cause manipulation (PEP 3134) */
PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *);
PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *);
/* Context manipulation (PEP 3134) */
PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *);
PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *);
#endif
/* */
#define PyExceptionClass_Check(x) \
(PyType_Check((x)) && \
PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
#define PyExceptionInstance_Check(x) \
PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
#define PyExceptionClass_Name(x) \
((char *)(((PyTypeObject*)(x))->tp_name))
#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
/* Predefined exceptions */
PyAPI_DATA(PyObject *) PyExc_BaseException;
PyAPI_DATA(PyObject *) PyExc_Exception;
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration;
#endif
PyAPI_DATA(PyObject *) PyExc_StopIteration;
PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
PyAPI_DATA(PyObject *) PyExc_LookupError;
PyAPI_DATA(PyObject *) PyExc_AssertionError;
PyAPI_DATA(PyObject *) PyExc_AttributeError;
PyAPI_DATA(PyObject *) PyExc_BufferError;
PyAPI_DATA(PyObject *) PyExc_EOFError;
PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
PyAPI_DATA(PyObject *) PyExc_OSError;
PyAPI_DATA(PyObject *) PyExc_ImportError;
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError;
#endif
PyAPI_DATA(PyObject *) PyExc_IndexError;
PyAPI_DATA(PyObject *) PyExc_KeyError;
PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
PyAPI_DATA(PyObject *) PyExc_MemoryError;
PyAPI_DATA(PyObject *) PyExc_NameError;
PyAPI_DATA(PyObject *) PyExc_OverflowError;
PyAPI_DATA(PyObject *) PyExc_RuntimeError;
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_DATA(PyObject *) PyExc_RecursionError;
#endif
PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
PyAPI_DATA(PyObject *) PyExc_SyntaxError;
PyAPI_DATA(PyObject *) PyExc_IndentationError;
PyAPI_DATA(PyObject *) PyExc_TabError;
PyAPI_DATA(PyObject *) PyExc_ReferenceError;
PyAPI_DATA(PyObject *) PyExc_SystemError;
PyAPI_DATA(PyObject *) PyExc_SystemExit;
PyAPI_DATA(PyObject *) PyExc_TypeError;
PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
PyAPI_DATA(PyObject *) PyExc_UnicodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
PyAPI_DATA(PyObject *) PyExc_ValueError;
PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_DATA(PyObject *) PyExc_BlockingIOError;
PyAPI_DATA(PyObject *) PyExc_BrokenPipeError;
PyAPI_DATA(PyObject *) PyExc_ChildProcessError;
PyAPI_DATA(PyObject *) PyExc_ConnectionError;
PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError;
PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError;
PyAPI_DATA(PyObject *) PyExc_ConnectionResetError;
PyAPI_DATA(PyObject *) PyExc_FileExistsError;
PyAPI_DATA(PyObject *) PyExc_FileNotFoundError;
PyAPI_DATA(PyObject *) PyExc_InterruptedError;
PyAPI_DATA(PyObject *) PyExc_IsADirectoryError;
PyAPI_DATA(PyObject *) PyExc_NotADirectoryError;
PyAPI_DATA(PyObject *) PyExc_PermissionError;
PyAPI_DATA(PyObject *) PyExc_ProcessLookupError;
PyAPI_DATA(PyObject *) PyExc_TimeoutError;
#endif
/* Compatibility aliases */
PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
PyAPI_DATA(PyObject *) PyExc_IOError;
#ifdef MS_WINDOWS
PyAPI_DATA(PyObject *) PyExc_WindowsError;
#endif
/* Predefined warning categories */
PyAPI_DATA(PyObject *) PyExc_Warning;
PyAPI_DATA(PyObject *) PyExc_UserWarning;
PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
PyAPI_DATA(PyObject *) PyExc_FutureWarning;
PyAPI_DATA(PyObject *) PyExc_ImportWarning;
PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
PyAPI_DATA(PyObject *) PyExc_BytesWarning;
PyAPI_DATA(PyObject *) PyExc_ResourceWarning;
/* Convenience functions */
PyAPI_FUNC(int) PyErr_BadArgument(void);
PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
PyObject *, PyObject *);
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects(
PyObject *, PyObject *, PyObject *);
#endif
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
PyObject *exc,
const char *filename /* decoded from the filesystem encoding */
);
#if defined(MS_WINDOWS) && !defined(Py_LIMITED_API)
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
PyObject *, const Py_UNICODE *);
#endif /* MS_WINDOWS */
PyAPI_FUNC(PyObject *) PyErr_Format(
PyObject *exception,
const char *format, /* ASCII-encoded string */
...
);
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(PyObject *) PyErr_FormatV(
PyObject *exception,
const char *format,
va_list vargs);
#endif
#ifndef Py_LIMITED_API
/* Like PyErr_Format(), but saves current exception as __context__ and
__cause__.
*/
PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause(
PyObject *exception,
const char *format, /* ASCII-encoded string */
...
);
#endif
#ifdef MS_WINDOWS
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
int ierr,
const char *filename /* decoded from the filesystem encoding */
);
#ifndef Py_LIMITED_API
/* XXX redeclare to use WSTRING */
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
int, const Py_UNICODE *);
#endif
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
PyObject *,int, PyObject *);
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects(
PyObject *,int, PyObject *, PyObject *);
#endif
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
PyObject *exc,
int ierr,
const char *filename /* decoded from the filesystem encoding */
);
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
PyObject *,int, const Py_UNICODE *);
#endif
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
#endif /* MS_WINDOWS */
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *,
PyObject *, PyObject *);
#endif
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *,
PyObject *);
#endif
/* Export the old function so that the existing API remains available: */
PyAPI_FUNC(void) PyErr_BadInternalCall(void);
PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno);
/* Mask the old API with a call to the new API for code compiled under
Python 2.0: */
#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
/* Function to create a new exception */
PyAPI_FUNC(PyObject *) PyErr_NewException(
const char *name, PyObject *base, PyObject *dict);
PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc(
const char *name, const char *doc, PyObject *base, PyObject *dict);
PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
/* In exceptions.c */
#ifndef Py_LIMITED_API
/* Helper that attempts to replace the current exception with one of the
* same type but with a prefix added to the exception text. The resulting
* exception description looks like:
*
* prefix (exc_type: original_exc_str)
*
* Only some exceptions can be safely replaced. If the function determines
* it isn't safe to perform the replacement, it will leave the original
* unmodified exception in place.
*
* Returns a borrowed reference to the new exception (if any), NULL if the
* existing exception was left in place.
*/
PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause(
const char *prefix_format, /* ASCII-encoded string */
...
);
#endif
/* In sigcheck.c or signalmodule.c */
PyAPI_FUNC(int) PyErr_CheckSignals(void);
PyAPI_FUNC(void) PyErr_SetInterrupt(void);
/* In signalmodule.c */
#ifndef Py_LIMITED_API
int PySignal_SetWakeupFd(int fd);
#endif
/* Support for adding program text to SyntaxErrors */
PyAPI_FUNC(void) PyErr_SyntaxLocation(
const char *filename, /* decoded from the filesystem encoding */
int lineno);
PyAPI_FUNC(void) PyErr_SyntaxLocationEx(
const char *filename, /* decoded from the filesystem encoding */
int lineno,
int col_offset);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) PyErr_SyntaxLocationObject(
PyObject *filename,
int lineno,
int col_offset);
#endif
PyAPI_FUNC(PyObject *) PyErr_ProgramText(
const char *filename, /* decoded from the filesystem encoding */
int lineno);
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject(
PyObject *filename,
int lineno);
#endif
/* The following functions are used to create and modify unicode
exceptions from C */
/* create a UnicodeDecodeError object */
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
const char *encoding, /* UTF-8 encoded string */
const char *object,
Py_ssize_t length,
Py_ssize_t start,
Py_ssize_t end,
const char *reason /* UTF-8 encoded string */
);
/* create a UnicodeEncodeError object */
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
const char *encoding, /* UTF-8 encoded string */
const Py_UNICODE *object,
Py_ssize_t length,
Py_ssize_t start,
Py_ssize_t end,
const char *reason /* UTF-8 encoded string */
);
#endif
/* create a UnicodeTranslateError object */
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
const Py_UNICODE *object,
Py_ssize_t length,
Py_ssize_t start,
Py_ssize_t end,
const char *reason /* UTF-8 encoded string */
);
PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create(
PyObject *object,
Py_ssize_t start,
Py_ssize_t end,
const char *reason /* UTF-8 encoded string */
);
#endif
/* get the encoding attribute */
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);
/* get the object attribute */
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
/* get the value of the start attribute (the int * may not be NULL)
return 0 on success, -1 on failure */
PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
/* assign a new value to the start attribute
return 0 on success, -1 on failure */
PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
/* get the value of the end attribute (the int *may not be NULL)
return 0 on success, -1 on failure */
PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
/* assign a new value to the end attribute
return 0 on success, -1 on failure */
PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
/* get the value of the reason attribute */
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);
PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
/* assign a new value to the reason attribute
return 0 on success, -1 on failure */
PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
PyObject *exc,
const char *reason /* UTF-8 encoded string */
);
PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
PyObject *exc,
const char *reason /* UTF-8 encoded string */
);
PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
PyObject *exc,
const char *reason /* UTF-8 encoded string */
);
/* These APIs aren't really part of the error implementation, but
often needed to format error messages; the native C lib APIs are
not available on all platforms, which is why we provide emulations
for those platforms in Python/mysnprintf.c,
WARNING: The return value of snprintf varies across platforms; do
not rely on any particular behavior; eventually the C99 defn may
be reliable.
*/
#if defined(MS_WIN32) && !defined(HAVE_SNPRINTF)
# define HAVE_SNPRINTF
# define snprintf _snprintf
# define vsnprintf _vsnprintf
#endif
#include <stdarg.h>
PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...)
Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
#ifdef __cplusplus
}
#endif
#endif /* !Py_ERRORS_H */
| gpl-2.0 |
JB1tz/Moto_omap3_ics_kernel | drivers/input/input.c | 45010 | /*
* The input core
*
* Copyright (c) 1999-2002 Vojtech Pavlik
*/
/*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <linux/init.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/major.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/poll.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/rcupdate.h>
#include <linux/smp_lock.h>
#ifdef CONFIG_PM_DEEPSLEEP
#include <linux/suspend.h>
#endif
MODULE_AUTHOR("Vojtech Pavlik <[email protected]>");
MODULE_DESCRIPTION("Input core");
MODULE_LICENSE("GPL");
#define INPUT_DEVICES 256
/*
* EV_ABS events which should not be cached are listed here.
*/
static unsigned int input_abs_bypass_init_data[] __initdata = {
ABS_MT_TOUCH_MAJOR,
ABS_MT_TOUCH_MINOR,
ABS_MT_WIDTH_MAJOR,
ABS_MT_WIDTH_MINOR,
ABS_MT_ORIENTATION,
ABS_MT_POSITION_X,
ABS_MT_POSITION_Y,
ABS_MT_TOOL_TYPE,
ABS_MT_BLOB_ID,
ABS_MT_TRACKING_ID,
ABS_DISTANCE,
ABS_RUDDER,
0
};
static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
static LIST_HEAD(input_dev_list);
static LIST_HEAD(input_handler_list);
/*
* input_mutex protects access to both input_dev_list and input_handler_list.
* This also causes input_[un]register_device and input_[un]register_handler
* be mutually exclusive which simplifies locking in drivers implementing
* input handlers.
*/
static DEFINE_MUTEX(input_mutex);
static struct input_handler *input_table[8];
static inline int is_event_supported(unsigned int code,
unsigned long *bm, unsigned int max)
{
return code <= max && test_bit(code, bm);
}
static int input_defuzz_abs_event(int value, int old_val, int fuzz)
{
if (fuzz) {
if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
return old_val;
if (value > old_val - fuzz && value < old_val + fuzz)
return (old_val * 3 + value) / 4;
if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
return (old_val + value) / 2;
}
return value;
}
/*
* Pass event through all open handles. This function is called with
* dev->event_lock held and interrupts disabled.
*/
static void input_pass_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
rcu_read_lock();
handle = rcu_dereference(dev->grab);
if (handle)
handle->handler->event(handle, type, code, value);
else
list_for_each_entry_rcu(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle,
type, code, value);
rcu_read_unlock();
}
/*
* Generate software autorepeat event. Note that we take
* dev->event_lock here to avoid racing with input_event
* which may cause keys get "stuck".
*/
static void input_repeat_key(unsigned long data)
{
struct input_dev *dev = (void *) data;
unsigned long flags;
spin_lock_irqsave(&dev->event_lock, flags);
if (test_bit(dev->repeat_key, dev->key) &&
is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
input_pass_event(dev, EV_KEY, dev->repeat_key, 2);
if (dev->sync) {
/*
* Only send SYN_REPORT if we are not in a middle
* of driver parsing a new hardware packet.
* Otherwise assume that the driver will send
* SYN_REPORT once it's done.
*/
input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
}
if (dev->rep[REP_PERIOD])
mod_timer(&dev->timer, jiffies +
msecs_to_jiffies(dev->rep[REP_PERIOD]));
}
spin_unlock_irqrestore(&dev->event_lock, flags);
}
static void input_start_autorepeat(struct input_dev *dev, int code)
{
if (test_bit(EV_REP, dev->evbit) &&
dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
dev->timer.data) {
dev->repeat_key = code;
mod_timer(&dev->timer,
jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
}
}
static void input_stop_autorepeat(struct input_dev *dev)
{
del_timer(&dev->timer);
}
#define INPUT_IGNORE_EVENT 0
#define INPUT_PASS_TO_HANDLERS 1
#define INPUT_PASS_TO_DEVICE 2
#define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
static void input_handle_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
int disposition = INPUT_IGNORE_EVENT;
trace_mark(input, input_event,
"type %u code %u value %d", type, code, value);
switch (type) {
case EV_SYN:
switch (code) {
case SYN_CONFIG:
disposition = INPUT_PASS_TO_ALL;
break;
case SYN_REPORT:
if (!dev->sync) {
dev->sync = 1;
disposition = INPUT_PASS_TO_HANDLERS;
}
break;
case SYN_MT_REPORT:
dev->sync = 0;
disposition = INPUT_PASS_TO_HANDLERS;
break;
}
break;
case EV_KEY:
if (is_event_supported(code, dev->keybit, KEY_MAX) &&
!!test_bit(code, dev->key) != value) {
if (value != 2) {
__change_bit(code, dev->key);
if (value)
input_start_autorepeat(dev, code);
else
input_stop_autorepeat(dev);
}
disposition = INPUT_PASS_TO_HANDLERS;
#ifdef CONFIG_PM_DEEPSLEEP
if (get_deepsleep_mode() && code != KEY_END)
disposition = INPUT_IGNORE_EVENT;
#endif
}
break;
case EV_SW:
if (is_event_supported(code, dev->swbit, SW_MAX) &&
!!test_bit(code, dev->sw) != value) {
__change_bit(code, dev->sw);
disposition = INPUT_PASS_TO_HANDLERS;
#ifdef CONFIG_PM_DEEPSLEEP
if (get_deepsleep_mode() && value == 0)
disposition = INPUT_IGNORE_EVENT;
#endif
}
break;
case EV_ABS:
if (is_event_supported(code, dev->absbit, ABS_MAX)) {
if (test_bit(code, input_abs_bypass)) {
disposition = INPUT_PASS_TO_HANDLERS;
break;
}
value = input_defuzz_abs_event(value,
dev->abs[code], dev->absfuzz[code]);
if (dev->abs[code] != value) {
dev->abs[code] = value;
disposition = INPUT_PASS_TO_HANDLERS;
}
}
break;
case EV_REL:
if (is_event_supported(code, dev->relbit, REL_MAX) && value)
disposition = INPUT_PASS_TO_HANDLERS;
break;
case EV_MSC:
if (is_event_supported(code, dev->mscbit, MSC_MAX))
disposition = INPUT_PASS_TO_ALL;
break;
case EV_LED:
if (is_event_supported(code, dev->ledbit, LED_MAX) &&
!!test_bit(code, dev->led) != value) {
__change_bit(code, dev->led);
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_SND:
if (is_event_supported(code, dev->sndbit, SND_MAX)) {
if (!!test_bit(code, dev->snd) != !!value)
__change_bit(code, dev->snd);
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_REP:
if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
dev->rep[code] = value;
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_FF:
if (value >= 0)
disposition = INPUT_PASS_TO_ALL;
break;
case EV_PWR:
disposition = INPUT_PASS_TO_ALL;
break;
}
if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
dev->sync = 0;
if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
dev->event(dev, type, code, value);
if (disposition & INPUT_PASS_TO_HANDLERS)
input_pass_event(dev, type, code, value);
}
/**
* input_event() - report new input event
* @dev: device that generated the event
* @type: type of the event
* @code: event code
* @value: value of the event
*
* This function should be used by drivers implementing various input
* devices. See also input_inject_event().
*/
void input_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
unsigned long flags;
if (is_event_supported(type, dev->evbit, EV_MAX)) {
spin_lock_irqsave(&dev->event_lock, flags);
add_input_randomness(type, code, value);
input_handle_event(dev, type, code, value);
spin_unlock_irqrestore(&dev->event_lock, flags);
}
}
EXPORT_SYMBOL(input_event);
/**
* input_inject_event() - send input event from input handler
* @handle: input handle to send event through
* @type: type of the event
* @code: event code
* @value: value of the event
*
* Similar to input_event() but will ignore event if device is
* "grabbed" and handle injecting event is not the one that owns
* the device.
*/
void input_inject_event(struct input_handle *handle,
unsigned int type, unsigned int code, int value)
{
struct input_dev *dev = handle->dev;
struct input_handle *grab;
unsigned long flags;
if (is_event_supported(type, dev->evbit, EV_MAX)) {
spin_lock_irqsave(&dev->event_lock, flags);
rcu_read_lock();
grab = rcu_dereference(dev->grab);
if (!grab || grab == handle)
input_handle_event(dev, type, code, value);
rcu_read_unlock();
spin_unlock_irqrestore(&dev->event_lock, flags);
}
}
EXPORT_SYMBOL(input_inject_event);
/**
* input_grab_device - grabs device for exclusive use
* @handle: input handle that wants to own the device
*
* When a device is grabbed by an input handle all events generated by
* the device are delivered only to this handle. Also events injected
* by other input handles are ignored while device is grabbed.
*/
int input_grab_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
int retval;
retval = mutex_lock_interruptible(&dev->mutex);
if (retval)
return retval;
if (dev->grab) {
retval = -EBUSY;
goto out;
}
rcu_assign_pointer(dev->grab, handle);
synchronize_rcu();
out:
mutex_unlock(&dev->mutex);
return retval;
}
EXPORT_SYMBOL(input_grab_device);
static void __input_release_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
if (dev->grab == handle) {
rcu_assign_pointer(dev->grab, NULL);
/* Make sure input_pass_event() notices that grab is gone */
synchronize_rcu();
list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open && handle->handler->start)
handle->handler->start(handle);
}
}
/**
* input_release_device - release previously grabbed device
* @handle: input handle that owns the device
*
* Releases previously grabbed device so that other input handles can
* start receiving input events. Upon release all handlers attached
* to the device have their start() method called so they have a change
* to synchronize device state with the rest of the system.
*/
void input_release_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
mutex_lock(&dev->mutex);
__input_release_device(handle);
mutex_unlock(&dev->mutex);
}
EXPORT_SYMBOL(input_release_device);
/**
* input_open_device - open input device
* @handle: handle through which device is being accessed
*
* This function should be called by input handlers when they
* want to start receive events from given input device.
*/
int input_open_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
int retval;
retval = mutex_lock_interruptible(&dev->mutex);
if (retval)
return retval;
if (dev->going_away) {
retval = -ENODEV;
goto out;
}
handle->open++;
if (!dev->users++ && dev->open)
retval = dev->open(dev);
if (retval) {
dev->users--;
if (!--handle->open) {
/*
* Make sure we are not delivering any more events
* through this handle
*/
synchronize_rcu();
}
}
out:
mutex_unlock(&dev->mutex);
return retval;
}
EXPORT_SYMBOL(input_open_device);
int input_flush_device(struct input_handle *handle, struct file *file)
{
struct input_dev *dev = handle->dev;
int retval;
retval = mutex_lock_interruptible(&dev->mutex);
if (retval)
return retval;
if (dev->flush)
retval = dev->flush(dev, file);
mutex_unlock(&dev->mutex);
return retval;
}
EXPORT_SYMBOL(input_flush_device);
/**
* input_close_device - close input device
* @handle: handle through which device is being accessed
*
* This function should be called by input handlers when they
* want to stop receive events from given input device.
*/
void input_close_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
mutex_lock(&dev->mutex);
__input_release_device(handle);
if (!--dev->users && dev->close)
dev->close(dev);
if (!--handle->open) {
/*
* synchronize_rcu() makes sure that input_pass_event()
* completed and that no more input events are delivered
* through this handle
*/
synchronize_rcu();
}
mutex_unlock(&dev->mutex);
}
EXPORT_SYMBOL(input_close_device);
/*
* Prepare device for unregistering
*/
static void input_disconnect_device(struct input_dev *dev)
{
struct input_handle *handle;
int code;
/*
* Mark device as going away. Note that we take dev->mutex here
* not to protect access to dev->going_away but rather to ensure
* that there are no threads in the middle of input_open_device()
*/
mutex_lock(&dev->mutex);
dev->going_away = true;
mutex_unlock(&dev->mutex);
spin_lock_irq(&dev->event_lock);
/*
* Simulate keyup events for all pressed keys so that handlers
* are not left with "stuck" keys. The driver may continue
* generate events even after we done here but they will not
* reach any handlers.
*/
if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
for (code = 0; code <= KEY_MAX; code++) {
if (is_event_supported(code, dev->keybit, KEY_MAX) &&
__test_and_clear_bit(code, dev->key)) {
input_pass_event(dev, EV_KEY, code, 0);
}
}
input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
}
list_for_each_entry(handle, &dev->h_list, d_node)
handle->open = 0;
spin_unlock_irq(&dev->event_lock);
}
static int input_fetch_keycode(struct input_dev *dev, int scancode)
{
switch (dev->keycodesize) {
case 1:
return ((u8 *)dev->keycode)[scancode];
case 2:
return ((u16 *)dev->keycode)[scancode];
default:
return ((u32 *)dev->keycode)[scancode];
}
}
static int input_default_getkeycode(struct input_dev *dev,
int scancode, int *keycode)
{
if (!dev->keycodesize)
return -EINVAL;
if (scancode >= dev->keycodemax)
return -EINVAL;
*keycode = input_fetch_keycode(dev, scancode);
return 0;
}
static int input_default_setkeycode(struct input_dev *dev,
int scancode, int keycode)
{
int old_keycode;
int i;
if (scancode >= dev->keycodemax)
return -EINVAL;
if (!dev->keycodesize)
return -EINVAL;
if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
return -EINVAL;
switch (dev->keycodesize) {
case 1: {
u8 *k = (u8 *)dev->keycode;
old_keycode = k[scancode];
k[scancode] = keycode;
break;
}
case 2: {
u16 *k = (u16 *)dev->keycode;
old_keycode = k[scancode];
k[scancode] = keycode;
break;
}
default: {
u32 *k = (u32 *)dev->keycode;
old_keycode = k[scancode];
k[scancode] = keycode;
break;
}
}
clear_bit(old_keycode, dev->keybit);
set_bit(keycode, dev->keybit);
for (i = 0; i < dev->keycodemax; i++) {
if (input_fetch_keycode(dev, i) == old_keycode) {
set_bit(old_keycode, dev->keybit);
break; /* Setting the bit twice is useless, so break */
}
}
return 0;
}
/**
* input_get_keycode - retrieve keycode currently mapped to a given scancode
* @dev: input device which keymap is being queried
* @scancode: scancode (or its equivalent for device in question) for which
* keycode is needed
* @keycode: result
*
* This function should be called by anyone interested in retrieving current
* keymap. Presently keyboard and evdev handlers use it.
*/
int input_get_keycode(struct input_dev *dev, int scancode, int *keycode)
{
if (scancode < 0)
return -EINVAL;
return dev->getkeycode(dev, scancode, keycode);
}
EXPORT_SYMBOL(input_get_keycode);
/**
* input_get_keycode - assign new keycode to a given scancode
* @dev: input device which keymap is being updated
* @scancode: scancode (or its equivalent for device in question)
* @keycode: new keycode to be assigned to the scancode
*
* This function should be called by anyone needing to update current
* keymap. Presently keyboard and evdev handlers use it.
*/
int input_set_keycode(struct input_dev *dev, int scancode, int keycode)
{
unsigned long flags;
int old_keycode;
int retval;
if (scancode < 0)
return -EINVAL;
if (keycode < 0 || keycode > KEY_MAX)
return -EINVAL;
spin_lock_irqsave(&dev->event_lock, flags);
retval = dev->getkeycode(dev, scancode, &old_keycode);
if (retval)
goto out;
retval = dev->setkeycode(dev, scancode, keycode);
if (retval)
goto out;
/*
* Simulate keyup event if keycode is not present
* in the keymap anymore
*/
if (test_bit(EV_KEY, dev->evbit) &&
!is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
__test_and_clear_bit(old_keycode, dev->key)) {
input_pass_event(dev, EV_KEY, old_keycode, 0);
if (dev->sync)
input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
}
out:
spin_unlock_irqrestore(&dev->event_lock, flags);
return retval;
}
EXPORT_SYMBOL(input_set_keycode);
#define MATCH_BIT(bit, max) \
for (i = 0; i < BITS_TO_LONGS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != BITS_TO_LONGS(max)) \
continue;
static const struct input_device_id *input_match_device(const struct input_device_id *id,
struct input_dev *dev)
{
int i;
for (; id->flags || id->driver_info; id++) {
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
if (id->bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->vendor != dev->id.vendor)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;
MATCH_BIT(evbit, EV_MAX);
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
MATCH_BIT(swbit, SW_MAX);
return id;
}
return NULL;
}
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
if (handler->blacklist && input_match_device(handler->blacklist, dev))
return -ENODEV;
id = input_match_device(handler->id_table, dev);
if (!id)
return -ENODEV;
error = handler->connect(handler, dev, id);
if (error && error != -ENODEV)
printk(KERN_ERR
"input: failed to attach handler %s to device %s, "
"error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_bus_input_dir;
static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
static int input_devices_state;
static inline void input_wakeup_procfs_readers(void)
{
input_devices_state++;
wake_up(&input_devices_poll_wait);
}
static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
{
poll_wait(file, &input_devices_poll_wait, wait);
if (file->f_version != input_devices_state) {
file->f_version = input_devices_state;
return POLLIN | POLLRDNORM;
}
return 0;
}
union input_seq_state {
struct {
unsigned short pos;
bool mutex_acquired;
};
void *p;
};
static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
{
union input_seq_state *state = (union input_seq_state *)&seq->private;
int error;
/* We need to fit into seq->private pointer */
BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
error = mutex_lock_interruptible(&input_mutex);
if (error) {
state->mutex_acquired = false;
return ERR_PTR(error);
}
state->mutex_acquired = true;
return seq_list_start(&input_dev_list, *pos);
}
static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
return seq_list_next(v, &input_dev_list, pos);
}
static void input_seq_stop(struct seq_file *seq, void *v)
{
union input_seq_state *state = (union input_seq_state *)&seq->private;
if (state->mutex_acquired)
mutex_unlock(&input_mutex);
}
static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
unsigned long *bitmap, int max)
{
int i;
for (i = BITS_TO_LONGS(max) - 1; i > 0; i--)
if (bitmap[i])
break;
seq_printf(seq, "B: %s=", name);
for (; i >= 0; i--)
seq_printf(seq, "%lx%s", bitmap[i], i > 0 ? " " : "");
seq_putc(seq, '\n');
}
static int input_devices_seq_show(struct seq_file *seq, void *v)
{
struct input_dev *dev = container_of(v, struct input_dev, node);
const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
struct input_handle *handle;
seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
seq_printf(seq, "H: Handlers=");
list_for_each_entry(handle, &dev->h_list, d_node)
seq_printf(seq, "%s ", handle->name);
seq_putc(seq, '\n');
input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
if (test_bit(EV_KEY, dev->evbit))
input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
if (test_bit(EV_REL, dev->evbit))
input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
if (test_bit(EV_ABS, dev->evbit))
input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
if (test_bit(EV_MSC, dev->evbit))
input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
if (test_bit(EV_LED, dev->evbit))
input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
if (test_bit(EV_SND, dev->evbit))
input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
if (test_bit(EV_FF, dev->evbit))
input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
if (test_bit(EV_SW, dev->evbit))
input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
seq_putc(seq, '\n');
kfree(path);
return 0;
}
static const struct seq_operations input_devices_seq_ops = {
.start = input_devices_seq_start,
.next = input_devices_seq_next,
.stop = input_seq_stop,
.show = input_devices_seq_show,
};
static int input_proc_devices_open(struct inode *inode, struct file *file)
{
return seq_open(file, &input_devices_seq_ops);
}
static const struct file_operations input_devices_fileops = {
.owner = THIS_MODULE,
.open = input_proc_devices_open,
.poll = input_proc_devices_poll,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release,
};
static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
{
union input_seq_state *state = (union input_seq_state *)&seq->private;
int error;
/* We need to fit into seq->private pointer */
BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
error = mutex_lock_interruptible(&input_mutex);
if (error) {
state->mutex_acquired = false;
return ERR_PTR(error);
}
state->mutex_acquired = true;
state->pos = *pos;
return seq_list_start(&input_handler_list, *pos);
}
static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
union input_seq_state *state = (union input_seq_state *)&seq->private;
state->pos = *pos + 1;
return seq_list_next(v, &input_handler_list, pos);
}
static int input_handlers_seq_show(struct seq_file *seq, void *v)
{
struct input_handler *handler = container_of(v, struct input_handler, node);
union input_seq_state *state = (union input_seq_state *)&seq->private;
seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
if (handler->fops)
seq_printf(seq, " Minor=%d", handler->minor);
seq_putc(seq, '\n');
return 0;
}
static const struct seq_operations input_handlers_seq_ops = {
.start = input_handlers_seq_start,
.next = input_handlers_seq_next,
.stop = input_seq_stop,
.show = input_handlers_seq_show,
};
static int input_proc_handlers_open(struct inode *inode, struct file *file)
{
return seq_open(file, &input_handlers_seq_ops);
}
static const struct file_operations input_handlers_fileops = {
.owner = THIS_MODULE,
.open = input_proc_handlers_open,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release,
};
static int __init input_proc_init(void)
{
struct proc_dir_entry *entry;
proc_bus_input_dir = proc_mkdir("bus/input", NULL);
if (!proc_bus_input_dir)
return -ENOMEM;
entry = proc_create("devices", 0, proc_bus_input_dir,
&input_devices_fileops);
if (!entry)
goto fail1;
entry = proc_create("handlers", 0, proc_bus_input_dir,
&input_handlers_fileops);
if (!entry)
goto fail2;
return 0;
fail2: remove_proc_entry("devices", proc_bus_input_dir);
fail1: remove_proc_entry("bus/input", NULL);
return -ENOMEM;
}
static void input_proc_exit(void)
{
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("bus/input", NULL);
}
#else /* !CONFIG_PROC_FS */
static inline void input_wakeup_procfs_readers(void) { }
static inline int input_proc_init(void) { return 0; }
static inline void input_proc_exit(void) { }
#endif
#define INPUT_DEV_STRING_ATTR_SHOW(name) \
static ssize_t input_dev_show_##name(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct input_dev *input_dev = to_input_dev(dev); \
\
return scnprintf(buf, PAGE_SIZE, "%s\n", \
input_dev->name ? input_dev->name : ""); \
} \
static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
INPUT_DEV_STRING_ATTR_SHOW(name);
INPUT_DEV_STRING_ATTR_SHOW(phys);
INPUT_DEV_STRING_ATTR_SHOW(uniq);
static int input_print_modalias_bits(char *buf, int size,
char name, unsigned long *bm,
unsigned int min_bit, unsigned int max_bit)
{
int len = 0, i;
len += snprintf(buf, max(size, 0), "%c", name);
for (i = min_bit; i < max_bit; i++)
if (bm[BIT_WORD(i)] & BIT_MASK(i))
len += snprintf(buf + len, max(size - len, 0), "%X,", i);
return len;
}
static int input_print_modalias(char *buf, int size, struct input_dev *id,
int add_cr)
{
int len;
len = snprintf(buf, max(size, 0),
"input:b%04Xv%04Xp%04Xe%04X-",
id->id.bustype, id->id.vendor,
id->id.product, id->id.version);
len += input_print_modalias_bits(buf + len, size - len,
'e', id->evbit, 0, EV_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'r', id->relbit, 0, REL_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'a', id->absbit, 0, ABS_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'm', id->mscbit, 0, MSC_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'l', id->ledbit, 0, LED_MAX);
len += input_print_modalias_bits(buf + len, size - len,
's', id->sndbit, 0, SND_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'f', id->ffbit, 0, FF_MAX);
len += input_print_modalias_bits(buf + len, size - len,
'w', id->swbit, 0, SW_MAX);
if (add_cr)
len += snprintf(buf + len, max(size - len, 0), "\n");
return len;
}
static ssize_t input_dev_show_modalias(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *id = to_input_dev(dev);
ssize_t len;
len = input_print_modalias(buf, PAGE_SIZE, id, 1);
return min_t(int, len, PAGE_SIZE);
}
static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
static struct attribute *input_dev_attrs[] = {
&dev_attr_name.attr,
&dev_attr_phys.attr,
&dev_attr_uniq.attr,
&dev_attr_modalias.attr,
NULL
};
static struct attribute_group input_dev_attr_group = {
.attrs = input_dev_attrs,
};
#define INPUT_DEV_ID_ATTR(name) \
static ssize_t input_dev_show_id_##name(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct input_dev *input_dev = to_input_dev(dev); \
return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
} \
static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
INPUT_DEV_ID_ATTR(bustype);
INPUT_DEV_ID_ATTR(vendor);
INPUT_DEV_ID_ATTR(product);
INPUT_DEV_ID_ATTR(version);
static struct attribute *input_dev_id_attrs[] = {
&dev_attr_bustype.attr,
&dev_attr_vendor.attr,
&dev_attr_product.attr,
&dev_attr_version.attr,
NULL
};
static struct attribute_group input_dev_id_attr_group = {
.name = "id",
.attrs = input_dev_id_attrs,
};
static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
int max, int add_cr)
{
int i;
int len = 0;
for (i = BITS_TO_LONGS(max) - 1; i > 0; i--)
if (bitmap[i])
break;
for (; i >= 0; i--)
len += snprintf(buf + len, max(buf_size - len, 0),
"%lx%s", bitmap[i], i > 0 ? " " : "");
if (add_cr)
len += snprintf(buf + len, max(buf_size - len, 0), "\n");
return len;
}
#define INPUT_DEV_CAP_ATTR(ev, bm) \
static ssize_t input_dev_show_cap_##bm(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct input_dev *input_dev = to_input_dev(dev); \
int len = input_print_bitmap(buf, PAGE_SIZE, \
input_dev->bm##bit, ev##_MAX, 1); \
return min_t(int, len, PAGE_SIZE); \
} \
static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
INPUT_DEV_CAP_ATTR(EV, ev);
INPUT_DEV_CAP_ATTR(KEY, key);
INPUT_DEV_CAP_ATTR(REL, rel);
INPUT_DEV_CAP_ATTR(ABS, abs);
INPUT_DEV_CAP_ATTR(MSC, msc);
INPUT_DEV_CAP_ATTR(LED, led);
INPUT_DEV_CAP_ATTR(SND, snd);
INPUT_DEV_CAP_ATTR(FF, ff);
INPUT_DEV_CAP_ATTR(SW, sw);
static struct attribute *input_dev_caps_attrs[] = {
&dev_attr_ev.attr,
&dev_attr_key.attr,
&dev_attr_rel.attr,
&dev_attr_abs.attr,
&dev_attr_msc.attr,
&dev_attr_led.attr,
&dev_attr_snd.attr,
&dev_attr_ff.attr,
&dev_attr_sw.attr,
NULL
};
static struct attribute_group input_dev_caps_attr_group = {
.name = "capabilities",
.attrs = input_dev_caps_attrs,
};
static const struct attribute_group *input_dev_attr_groups[] = {
&input_dev_attr_group,
&input_dev_id_attr_group,
&input_dev_caps_attr_group,
NULL
};
static void input_dev_release(struct device *device)
{
struct input_dev *dev = to_input_dev(device);
input_ff_destroy(dev);
kfree(dev);
module_put(THIS_MODULE);
}
/*
* Input uevent interface - loading event handlers based on
* device bitfields.
*/
static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
const char *name, unsigned long *bitmap, int max)
{
int len;
if (add_uevent_var(env, "%s=", name))
return -ENOMEM;
len = input_print_bitmap(&env->buf[env->buflen - 1],
sizeof(env->buf) - env->buflen,
bitmap, max, 0);
if (len >= (sizeof(env->buf) - env->buflen))
return -ENOMEM;
env->buflen += len;
return 0;
}
static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
struct input_dev *dev)
{
int len;
if (add_uevent_var(env, "MODALIAS="))
return -ENOMEM;
len = input_print_modalias(&env->buf[env->buflen - 1],
sizeof(env->buf) - env->buflen,
dev, 0);
if (len >= (sizeof(env->buf) - env->buflen))
return -ENOMEM;
env->buflen += len;
return 0;
}
#define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
do { \
int err = add_uevent_var(env, fmt, val); \
if (err) \
return err; \
} while (0)
#define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
do { \
int err = input_add_uevent_bm_var(env, name, bm, max); \
if (err) \
return err; \
} while (0)
#define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
do { \
int err = input_add_uevent_modalias_var(env, dev); \
if (err) \
return err; \
} while (0)
static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
{
struct input_dev *dev = to_input_dev(device);
INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
dev->id.bustype, dev->id.vendor,
dev->id.product, dev->id.version);
if (dev->name)
INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
if (dev->phys)
INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
if (dev->uniq)
INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
if (test_bit(EV_KEY, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
if (test_bit(EV_REL, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
if (test_bit(EV_ABS, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
if (test_bit(EV_MSC, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
if (test_bit(EV_LED, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
if (test_bit(EV_SND, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
if (test_bit(EV_FF, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
if (test_bit(EV_SW, dev->evbit))
INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
return 0;
}
#define INPUT_DO_TOGGLE(dev, type, bits, on) \
do { \
int i; \
bool active; \
\
if (!test_bit(EV_##type, dev->evbit)) \
break; \
\
for (i = 0; i < type##_MAX; i++) { \
if (!test_bit(i, dev->bits##bit)) \
continue; \
\
active = test_bit(i, dev->bits); \
if (!active && !on) \
continue; \
\
dev->event(dev, EV_##type, i, on ? active : 0); \
} \
} while (0)
#ifdef CONFIG_PM
static void input_dev_reset(struct input_dev *dev, bool activate)
{
if (!dev->event)
return;
INPUT_DO_TOGGLE(dev, LED, led, activate);
INPUT_DO_TOGGLE(dev, SND, snd, activate);
if (activate && test_bit(EV_REP, dev->evbit)) {
dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
}
}
static int input_dev_suspend(struct device *dev)
{
struct input_dev *input_dev = to_input_dev(dev);
mutex_lock(&input_dev->mutex);
input_dev_reset(input_dev, false);
mutex_unlock(&input_dev->mutex);
return 0;
}
static int input_dev_resume(struct device *dev)
{
struct input_dev *input_dev = to_input_dev(dev);
mutex_lock(&input_dev->mutex);
input_dev_reset(input_dev, true);
mutex_unlock(&input_dev->mutex);
return 0;
}
static const struct dev_pm_ops input_dev_pm_ops = {
.suspend = input_dev_suspend,
.resume = input_dev_resume,
.poweroff = input_dev_suspend,
.restore = input_dev_resume,
};
#endif /* CONFIG_PM */
static struct device_type input_dev_type = {
.groups = input_dev_attr_groups,
.release = input_dev_release,
.uevent = input_dev_uevent,
#ifdef CONFIG_PM
.pm = &input_dev_pm_ops,
#endif
};
static char *input_devnode(struct device *dev, mode_t *mode)
{
return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
}
struct class input_class = {
.name = "input",
.devnode = input_devnode,
};
EXPORT_SYMBOL_GPL(input_class);
/**
* input_allocate_device - allocate memory for new input device
*
* Returns prepared struct input_dev or NULL.
*
* NOTE: Use input_free_device() to free devices that have not been
* registered; input_unregister_device() should be used for already
* registered devices.
*/
struct input_dev *input_allocate_device(void)
{
struct input_dev *dev;
dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
if (dev) {
dev->dev.type = &input_dev_type;
dev->dev.class = &input_class;
device_initialize(&dev->dev);
mutex_init(&dev->mutex);
spin_lock_init(&dev->event_lock);
INIT_LIST_HEAD(&dev->h_list);
INIT_LIST_HEAD(&dev->node);
__module_get(THIS_MODULE);
}
return dev;
}
EXPORT_SYMBOL(input_allocate_device);
/**
* input_free_device - free memory occupied by input_dev structure
* @dev: input device to free
*
* This function should only be used if input_register_device()
* was not called yet or if it failed. Once device was registered
* use input_unregister_device() and memory will be freed once last
* reference to the device is dropped.
*
* Device should be allocated by input_allocate_device().
*
* NOTE: If there are references to the input device then memory
* will not be freed until last reference is dropped.
*/
void input_free_device(struct input_dev *dev)
{
if (dev)
input_put_device(dev);
}
EXPORT_SYMBOL(input_free_device);
/**
* input_set_capability - mark device as capable of a certain event
* @dev: device that is capable of emitting or accepting event
* @type: type of the event (EV_KEY, EV_REL, etc...)
* @code: event code
*
* In addition to setting up corresponding bit in appropriate capability
* bitmap the function also adjusts dev->evbit.
*/
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
{
switch (type) {
case EV_KEY:
__set_bit(code, dev->keybit);
break;
case EV_REL:
__set_bit(code, dev->relbit);
break;
case EV_ABS:
__set_bit(code, dev->absbit);
break;
case EV_MSC:
__set_bit(code, dev->mscbit);
break;
case EV_SW:
__set_bit(code, dev->swbit);
break;
case EV_LED:
__set_bit(code, dev->ledbit);
break;
case EV_SND:
__set_bit(code, dev->sndbit);
break;
case EV_FF:
__set_bit(code, dev->ffbit);
break;
case EV_PWR:
/* do nothing */
break;
default:
printk(KERN_ERR
"input_set_capability: unknown type %u (code %u)\n",
type, code);
dump_stack();
return;
}
__set_bit(type, dev->evbit);
}
EXPORT_SYMBOL(input_set_capability);
/**
* input_register_device - register device with input core
* @dev: device to be registered
*
* This function registers device with input core. The device must be
* allocated with input_allocate_device() and all it's capabilities
* set up before registering.
* If function fails the device must be freed with input_free_device().
* Once device has been successfully registered it can be unregistered
* with input_unregister_device(); input_free_device() should not be
* called in this case.
*/
int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);
struct input_handler *handler;
const char *path;
int error;
__set_bit(EV_SYN, dev->evbit);
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1);
error = device_add(&dev->dev);
if (error)
return error;
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
printk(KERN_INFO "input: %s as %s\n",
dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
kfree(path);
error = mutex_lock_interruptible(&input_mutex);
if (error) {
device_del(&dev->dev);
return error;
}
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
return 0;
}
EXPORT_SYMBOL(input_register_device);
/**
* input_unregister_device - unregister previously registered device
* @dev: device to be unregistered
*
* This function unregisters an input device. Once device is unregistered
* the caller should not try to access it as it may get freed at any moment.
*/
void input_unregister_device(struct input_dev *dev)
{
struct input_handle *handle, *next;
input_disconnect_device(dev);
mutex_lock(&input_mutex);
list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
handle->handler->disconnect(handle);
WARN_ON(!list_empty(&dev->h_list));
del_timer_sync(&dev->timer);
list_del_init(&dev->node);
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
device_unregister(&dev->dev);
}
EXPORT_SYMBOL(input_unregister_device);
/**
* input_register_handler - register a new input handler
* @handler: handler to be registered
*
* This function registers a new input handler (interface) for input
* devices in the system and attaches it to all input devices that
* are compatible with the handler.
*/
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;
}
list_add_tail(&handler->node, &input_handler_list);
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
out:
mutex_unlock(&input_mutex);
return retval;
}
EXPORT_SYMBOL(input_register_handler);
/**
* input_unregister_handler - unregisters an input handler
* @handler: handler to be unregistered
*
* This function disconnects a handler from its input devices and
* removes it from lists of known handlers.
*/
void input_unregister_handler(struct input_handler *handler)
{
struct input_handle *handle, *next;
mutex_lock(&input_mutex);
list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
handler->disconnect(handle);
WARN_ON(!list_empty(&handler->h_list));
list_del_init(&handler->node);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = NULL;
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
}
EXPORT_SYMBOL(input_unregister_handler);
/**
* input_register_handle - register a new input handle
* @handle: handle to register
*
* This function puts a new input handle onto device's
* and handler's lists so that events can flow through
* it once it is opened using input_open_device().
*
* This function is supposed to be called from handler's
* connect() method.
*/
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error;
/*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error;
list_add_tail_rcu(&handle->d_node, &dev->h_list);
mutex_unlock(&dev->mutex);
/*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
list_add_tail(&handle->h_node, &handler->h_list);
if (handler->start)
handler->start(handle);
return 0;
}
EXPORT_SYMBOL(input_register_handle);
/**
* input_unregister_handle - unregister an input handle
* @handle: handle to unregister
*
* This function removes input handle from device's
* and handler's lists.
*
* This function is supposed to be called from handler's
* disconnect() method.
*/
void input_unregister_handle(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
list_del_init(&handle->h_node);
/*
* Take dev->mutex to prevent race with input_release_device().
*/
mutex_lock(&dev->mutex);
list_del_rcu(&handle->d_node);
mutex_unlock(&dev->mutex);
synchronize_rcu();
}
EXPORT_SYMBOL(input_unregister_handle);
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler;
const struct file_operations *old_fops, *new_fops = NULL;
int err;
lock_kernel();
/* No load-on-demand here? */
handler = input_table[iminor(inode) >> 5];
if (!handler || !(new_fops = fops_get(handler->fops))) {
err = -ENODEV;
goto out;
}
/*
* That's _really_ odd. Usually NULL ->open means "nothing special",
* not "no device". Oh, well...
*/
if (!new_fops->open) {
fops_put(new_fops);
err = -ENODEV;
goto out;
}
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file);
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
out:
unlock_kernel();
return err;
}
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
static void __init input_init_abs_bypass(void)
{
const unsigned int *p;
for (p = input_abs_bypass_init_data; *p; p++)
input_abs_bypass[BIT_WORD(*p)] |= BIT_MASK(*p);
}
static int __init input_init(void)
{
int err;
input_init_abs_bypass();
err = class_register(&input_class);
if (err) {
printk(KERN_ERR "input: unable to register input_dev class\n");
return err;
}
err = input_proc_init();
if (err)
goto fail1;
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (err) {
printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
goto fail2;
}
return 0;
fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
static void __exit input_exit(void)
{
input_proc_exit();
unregister_chrdev(INPUT_MAJOR, "input");
class_unregister(&input_class);
}
subsys_initcall(input_init);
module_exit(input_exit);
| gpl-2.0 |
yevgeniy-logachev/CATB15Kernel | mediatek/custom/vt58/lk/include/target/cust_msdc.h | 1732 | #ifndef CUST_MSDC_H
#define CUST_MSDC_H
#define MSDC_CD_PIN_EN (1 << 0) /* card detection pin is wired */
#define MSDC_WP_PIN_EN (1 << 1) /* write protection pin is wired */
#define MSDC_RST_PIN_EN (1 << 2) /* emmc reset pin is wired */
#define MSDC_SDIO_IRQ (1 << 3) /* use internal sdio irq (bus) */
#define MSDC_EXT_SDIO_IRQ (1 << 4) /* use external sdio irq */
#define MSDC_REMOVABLE (1 << 5) /* removable slot */
#define MSDC_SYS_SUSPEND (1 << 6) /* suspended by system */
#define MSDC_HIGHSPEED (1 << 7) /* high-speed mode support */
#define MSDC_UHS1 (1 << 8) /* uhs-1 mode support */
#define MSDC_DDR (1 << 9) /* ddr mode support */
#define MSDC_SMPL_RISING (0)
#define MSDC_SMPL_FALLING (1)
typedef enum {
MSDC_CLKSRC_26MHZ = 0,
MSDC_CLKSRC_197MHZ = 1,
MSDC_CLKSRC_208MHZ = 2
} clk_source_t;
struct msdc_cust {
unsigned char clk_src; /* host clock source */
unsigned char cmd_edge; /* command latch edge */
unsigned char data_edge; /* data latch edge */
unsigned char clk_drv; /* clock pad driving */
unsigned char cmd_drv; /* command pad driving */
unsigned char dat_drv; /* data pad driving */
unsigned char data_pins; /* data pins */
unsigned int data_offset; /* data address offset */
unsigned int flags; /* hardware capability flags */
};
extern struct msdc_cust msdc_cap;
#endif /* end of _MSDC_CUST_H_ */
| gpl-2.0 |
FauxFaux/jdk9-jaxws | src/java.xml.ws/share/classes/com/sun/xml/internal/ws/config/metro/dev/FeatureReader.java | 1858 | /*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.xml.internal.ws.config.metro.dev;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventReader;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.WebServiceFeature;
/**
* Parses a XML fragment and is expected to return a corresponding WebServiceFeature.
*
* @author Fabian Ritzmann
*/
public interface FeatureReader<T extends WebServiceFeature> {
public static final QName ENABLED_ATTRIBUTE_NAME = new QName("enabled");
/**
* Parse an XML stream and return the corresponding WebServiceFeature instance.
*/
public T parse(XMLEventReader reader) throws WebServiceException;
}
| gpl-2.0 |
RaoulDebaze/TransmissionSync | transmissionbt/macosx/TransmissionHelp/html/troubleshoot.html | 3658 | <html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link media="all" rel="stylesheet" href="../styles/TransBody.css" />
<title>Troubleshooting a Closed port</title>
</head>
<body>
<div id="mainbox">
<div id="banner">
<a name="menus"></a>
<div id="machelp">
<a class="bread" href="../index.html">Transmission Help</a>
</div>
<div id="index">
<a class="leftborder" href="../html/Index2.html">Index</a></div>
</div>
</div>
<div id="pagetitle">
<h1>I cannot get Transmission's port to open! </h1>
</div>
<p>If your port is still not open, even after you have enabled automatic port forwarding, here are some tips you can use which may get it working.
<div summary="To do this" id="taskbox">
<p>If you are still having problems, open the Message Log (in the Window menu) and post the debug output on the <a href="http://transmission.m0k.org/forum/viewforum.php?f=2">support forums</a>.
<ol>
<li>Pause your torrents</li>
<li>Clear the log and set it to 'Debug'</li>
<li>Toggle "Automatically map port" in Network Preferences</li>
<li>Post the resultant output</li>
</ol>
</div>
<div id="pagetitle">
<h1>UPnP</h1>
</div>
<p>For UPnP compatible routers, make sure:
<ul>
<li>UPnP is enabled. Consult your router's documentation for instructions. If your router doesn't support UPnP, you will have to forward <a href="pfrouter.html">manually</a>.</li>
<li>DMZ mode is disabled.</li>
<li>The port has not already been forwarded manually.
</ul>
<div id="pagetitle">
<h1>AirPort</h1>
</div>
<p>If you have an Apple AirPort, make sure NAT-PMP is enabled.
<div summary="To do this" id="taskbox">
<ol>
<li>Open AirPort Utility (located in /Applications/Utilities)</li>
<li>Select your base station, and then choose Manual Setup from the Base Station menu. Enter the base station password if necessary.</li>
<li>Click Internet in the toolbar, and then check the "Enable NAT Port Mapping Protocol" checkbox.</li>
<li>Click "Update".</li>
</ol>
</div>
</div>
</div>
<div id="pagetitle">
<h1>Double NAT</h1>
</div>
<p>Another possible reason your port remains closed could be because your router is not the only device on the network which needs to be configured.
<p>For example, your network might resemble the following: <b>ADSL modem/router --> AirPort extreme --> MacBook.</b>
<p>If you have multiple routers in your home network (such as in the example above), you have two options. The easiest way is to turn one of the routers into 'Bridge mode' which means you then only have to configure one device rather than all of them. So, in our above example, we would set the AirPort extreme to 'Bridge'. See your router's help documentation for instructions.
<p>The second way is to map Transmission's port on all of the devices on your network.
Transmission can only automatically port map the router the computer is directly connected to. Any others in between this router and your modem will have to be <a href="pfrouter.html">forwarded manually</a>. For detailed instructions, <a href="http://www.portforward.com/help/doublerouterportforwarding.htm">click here</a>.
<p>Finally make sure the OS X firewall is either disabled, or you have <a href="pffirewall.html">allowed Transmission's port</a>.
The firewall can cause the port to remain closed, even if it has been successfully mapped by the router(s).
</div>
</div>
</body>
</html>
| gpl-2.0 |
rathoresrikant/Implementation-of-Curvy-RED-in-ns-3 | src/lte/model/lte-rrc-header.cc | 237854 | /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Lluis Parcerisa <[email protected]>
* Modified by:
* Danilo Abrignani <[email protected]> (Carrier Aggregation - GSoC 2015)
* Biljana Bojovic <[email protected]> (Carrier Aggregation)
*/
#include "ns3/log.h"
#include "ns3/lte-rrc-header.h"
#include <stdio.h>
#include <sstream>
#define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331
#define MAX_EARFCN 262143
#define MAX_RAT_CAPABILITIES 8
#define MAX_SI_MESSAGE 32
#define MAX_SIB 32
#define MAX_REPORT_CONFIG_ID 32
#define MAX_OBJECT_ID 32
#define MAX_MEAS_ID 32
#define MAX_CELL_MEAS 32
#define MAX_CELL_REPORT 8
#define MAX_SCELL_REPORT 5
#define MAX_SCELL_CONF 5
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("RrcHeader");
//////////////////// RrcAsn1Header class ///////////////////////////////
RrcAsn1Header::RrcAsn1Header ()
{
}
TypeId
RrcAsn1Header::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RrcAsn1Header")
.SetParent<Header> ()
.SetGroupName("Lte")
;
return tid;
}
TypeId
RrcAsn1Header::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
int
RrcAsn1Header::GetMessageType ()
{
return m_messageType;
}
void
RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbToAddModList) const
{
// Serialize DRB-ToAddModList sequence-of
SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1);
// Serialize the elements in the sequence-of list
std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin ();
for (; it != drbToAddModList.end (); it++)
{
// Serialize DRB-ToAddMod sequence
// 5 otional fields. Extension marker is present.
std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5> ();
drbToAddModListOptionalFieldsPresent.set (4,1); // eps-BearerIdentity present
drbToAddModListOptionalFieldsPresent.set (3,0); // pdcp-Config not present
drbToAddModListOptionalFieldsPresent.set (2,1); // rlc-Config present
drbToAddModListOptionalFieldsPresent.set (1,1); // logicalChannelIdentity present
drbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig present
SerializeSequence (drbToAddModListOptionalFieldsPresent,true);
// Serialize eps-BearerIdentity::=INTEGER (0..15)
SerializeInteger (it->epsBearerIdentity,0,15);
// Serialize drb-Identity ::= INTEGER (1..32)
SerializeInteger (it->drbIdentity,1,32);
switch (it->rlcConfig.choice)
{
case LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL:
// Serialize rlc-Config choice
SerializeChoice (4,1,true);
// Serialize UL-UM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (2,0); // sn-FieldLength
// Serialize DL-UM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (2,0); // sn-FieldLength
SerializeEnum (32,0); // t-Reordering
break;
case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL:
// Serialize rlc-Config choice
SerializeChoice (4,2,true);
// Serialize UL-UM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (2,0); // sn-FieldLength
break;
case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL:
// Serialize rlc-Config choice
SerializeChoice (4,3,true);
// Serialize DL-UM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (2,0); // sn-FieldLength
SerializeEnum (32,0); // t-Reordering
break;
case LteRrcSap::RlcConfig::AM:
default:
// Serialize rlc-Config choice
SerializeChoice (4,0,true);
// Serialize UL-AM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (64,0); // t-PollRetransmit
SerializeEnum (8,0); // pollPDU
SerializeEnum (16,0); // pollByte
SerializeEnum (8,0); // maxRetxThreshold
// Serialize DL-AM-RLC
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (32,0); // t-Reordering
SerializeEnum (64,0); // t-StatusProhibit
break;
}
// Serialize logicalChannelIdentity ::=INTEGER (3..10)
SerializeInteger (it->logicalChannelIdentity,3,10);
// Serialize logicalChannelConfig
SerializeLogicalChannelConfig (it->logicalChannelConfig);
}
}
void
RrcAsn1Header::SerializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> srbToAddModList) const
{
// Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod
SerializeSequenceOf (srbToAddModList.size (),2,1);
// Serialize the elements in the sequence-of list
std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin ();
for (; it != srbToAddModList.end (); it++)
{
// Serialize SRB-ToAddMod sequence
// 2 otional fields. Extension marker is present.
std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2> ();
srbToAddModListOptionalFieldsPresent.set (1,0); // rlc-Config not present
srbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig present
SerializeSequence (srbToAddModListOptionalFieldsPresent,true);
// Serialize srb-Identity ::= INTEGER (1..2)
SerializeInteger (it->srbIdentity,1,2);
// Serialize logicalChannelConfig choice
// 2 options, selected option 0 (var "explicitValue", of type LogicalChannelConfig)
SerializeChoice (2,0,false);
// Serialize LogicalChannelConfig
SerializeLogicalChannelConfig (it->logicalChannelConfig);
}
}
void
RrcAsn1Header::SerializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig logicalChannelConfig) const
{
// Serialize LogicalChannelConfig sequence
// 1 optional field (ul-SpecificParameters), which is present. Extension marker present.
SerializeSequence (std::bitset<1> (1),true);
// Serialize ul-SpecificParameters sequence
// 1 optional field (logicalChannelGroup), which is present. No extension marker.
SerializeSequence (std::bitset<1> (1),false);
// Serialize priority ::= INTEGER (1..16)
SerializeInteger (logicalChannelConfig.priority,1,16);
// Serialize prioritisedBitRate
int prioritizedBitRate;
switch (logicalChannelConfig.prioritizedBitRateKbps)
{
case 0:
prioritizedBitRate = 0;
break;
case 8:
prioritizedBitRate = 1;
break;
case 16:
prioritizedBitRate = 2;
break;
case 32:
prioritizedBitRate = 3;
break;
case 64:
prioritizedBitRate = 4;
break;
case 128:
prioritizedBitRate = 5;
break;
case 256:
prioritizedBitRate = 6;
break;
default:
prioritizedBitRate = 7; // Infinity
}
SerializeEnum (16,prioritizedBitRate);
// Serialize bucketSizeDuration
int bucketSizeDuration;
switch (logicalChannelConfig.bucketSizeDurationMs)
{
case 50:
bucketSizeDuration = 0;
break;
case 100:
bucketSizeDuration = 1;
break;
case 150:
bucketSizeDuration = 2;
break;
case 300:
bucketSizeDuration = 3;
break;
case 500:
bucketSizeDuration = 4;
break;
case 1000:
bucketSizeDuration = 5;
break;
default:
bucketSizeDuration = 5;
}
SerializeEnum (8,bucketSizeDuration);
// Serialize logicalChannelGroup ::= INTEGER (0..3)
SerializeInteger (logicalChannelConfig.logicalChannelGroup,0,3);
}
void
RrcAsn1Header::SerializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const
{
// Serialize PhysicalConfigDedicated Sequence
std::bitset<10> optionalFieldsPhysicalConfigDedicated;
optionalFieldsPhysicalConfigDedicated.set (9,physicalConfigDedicated.havePdschConfigDedicated); // pdsch-ConfigDedicated
optionalFieldsPhysicalConfigDedicated.set (8,0); // pucch-ConfigDedicated not present
optionalFieldsPhysicalConfigDedicated.set (7,0); // pusch-ConfigDedicated not present
optionalFieldsPhysicalConfigDedicated.set (6,0); // uplinkPowerControlDedicated not present
optionalFieldsPhysicalConfigDedicated.set (5,0); // tpc-PDCCH-ConfigPUCCH not present
optionalFieldsPhysicalConfigDedicated.set (4,0); // tpc-PDCCH-ConfigPUSCH not present
optionalFieldsPhysicalConfigDedicated.set (3,0); // cqi-ReportConfig not present
optionalFieldsPhysicalConfigDedicated.set (2,physicalConfigDedicated.haveSoundingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated
optionalFieldsPhysicalConfigDedicated.set (1,physicalConfigDedicated.haveAntennaInfoDedicated); // antennaInfo
optionalFieldsPhysicalConfigDedicated.set (0,0); // schedulingRequestConfig not present
SerializeSequence (optionalFieldsPhysicalConfigDedicated,true);
if (physicalConfigDedicated.havePdschConfigDedicated)
{
// Serialize Pdsch-ConfigDedicated Sequence:
// 0 optional / default fields, no extension marker.
SerializeSequence (std::bitset<0> (),false);
// Serialize p-a
// Assuming the value in the struct is the enum index
SerializeEnum (8,physicalConfigDedicated.pdschConfigDedicated.pa);
// Serialize release
SerializeNull ();
}
if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
{
// Serialize SoundingRS-UL-ConfigDedicated choice:
switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type)
{
case LteRrcSap::SoundingRsUlConfigDedicated::RESET:
SerializeChoice (2,0,false);
SerializeNull ();
break;
case LteRrcSap::SoundingRsUlConfigDedicated::SETUP:
default:
// 2 options, selected: 1 (setup)
SerializeChoice (2,1,false);
// Serialize setup sequence
// 0 optional / default fields, no extension marker.
SerializeSequence (std::bitset<0> (),false);
// Serialize srs-Bandwidth
SerializeEnum (4,physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth);
// Serialize srs-HoppingBandwidth
SerializeEnum (4,0);
// Serialize freqDomainPosition
SerializeInteger (0,0,23);
// Serialize duration
SerializeBoolean (false);
// Serialize srs-ConfigIndex
SerializeInteger (physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex,0,1023);
// Serialize transmissionComb
SerializeInteger (0,0,1);
// Serialize cyclicShift
SerializeEnum (8,0);
break;
}
}
if (physicalConfigDedicated.haveAntennaInfoDedicated)
{
// Serialize antennaInfo choice
// 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
SerializeChoice (2,0,false);
// Serialize AntennaInfoDedicated sequence
// 1 optional parameter, not present. No extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Serialize transmissionMode
// Assuming the value in the struct is the enum index
SerializeEnum (8,physicalConfigDedicated.antennaInfo.transmissionMode);
// Serialize ue-TransmitAntennaSelection choice
SerializeChoice (2,0,false);
// Serialize release
SerializeNull ();
}
}
void
RrcAsn1Header::SerializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
{
bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.empty ();
bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.empty ();
bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseList.empty ();
// 6 optional fields. Extension marker is present.
std::bitset<6> optionalFieldsPresent = std::bitset<6> ();
optionalFieldsPresent.set (5,isSrbToAddModListPresent); // srb-ToAddModList present
optionalFieldsPresent.set (4,isDrbToAddModListPresent); // drb-ToAddModList present
optionalFieldsPresent.set (3,isDrbToReleaseListPresent); // drb-ToReleaseList present
optionalFieldsPresent.set (2,0); // mac-MainConfig not present
optionalFieldsPresent.set (1,0); // sps-Config not present
optionalFieldsPresent.set (0,(radioResourceConfigDedicated.havePhysicalConfigDedicated) ? 1 : 0);
SerializeSequence (optionalFieldsPresent,true);
// Serialize srbToAddModList
if (isSrbToAddModListPresent)
{
SerializeSrbToAddModList (radioResourceConfigDedicated.srbToAddModList);
}
// Serialize drbToAddModList
if (isDrbToAddModListPresent)
{
SerializeDrbToAddModList (radioResourceConfigDedicated.drbToAddModList);
}
// Serialize drbToReleaseList
if (isDrbToReleaseListPresent)
{
SerializeSequenceOf (radioResourceConfigDedicated.drbToReleaseList.size (),MAX_DRB,1);
std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToReleaseList.begin ();
for (; it != radioResourceConfigDedicated.drbToReleaseList.end (); it++)
{
// DRB-Identity ::= INTEGER (1..32)
SerializeInteger (*it,1,32);
}
}
if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
{
SerializePhysicalConfigDedicated (radioResourceConfigDedicated.physicalConfigDedicated);
}
}
void
RrcAsn1Header::SerializeSystemInformationBlockType1 (LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const
{
// 3 optional fields, no extension marker.
std::bitset<3> sysInfoBlk1Opts;
sysInfoBlk1Opts.set (2,0); // p-Max absent
sysInfoBlk1Opts.set (1,0); // tdd-Config absent
sysInfoBlk1Opts.set (0,0); // nonCriticalExtension absent
SerializeSequence (sysInfoBlk1Opts,false);
// Serialize cellAccessRelatedInfo
// 1 optional field (csgIdentity) which is present, no extension marker.
SerializeSequence (std::bitset<1> (1),false);
// Serialize plmn-IdentityList
SerializeSequenceOf (1,6,1);
// PLMN-IdentityInfo
SerializeSequence (std::bitset<0> (),false);
SerializePlmnIdentity (systemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity);
// Serialize trackingAreaCode
SerializeBitstring (std::bitset<16> (0));
// Serialize cellIdentity
SerializeBitstring (std::bitset<28> (systemInformationBlockType1.cellAccessRelatedInfo.cellIdentity));
// Serialize cellBarred
SerializeEnum (2,0);
// Serialize intraFreqReselection
SerializeEnum (2,0);
// Serialize csg-Indication
SerializeBoolean (systemInformationBlockType1.cellAccessRelatedInfo.csgIndication);
// Serialize csg-Identity
SerializeBitstring (std::bitset<27> (systemInformationBlockType1.cellAccessRelatedInfo.csgIdentity));
// Serialize cellSelectionInfo
SerializeSequence (std::bitset<1> (0),false);
// Serialize q-RxLevMin
SerializeInteger (-50,-70,-22);
// Serialize freqBandIndicator
SerializeInteger (1,1,64);
// Serialize schedulingInfoList
SerializeSequenceOf (1,MAX_SI_MESSAGE,1);
// SchedulingInfo
SerializeSequence (std::bitset<0> (),false);
// si-Periodicity
SerializeEnum (7,0);
// sib-MappingInfo
SerializeSequenceOf (0,MAX_SIB - 1,0);
// Serialize si-WindowLength
SerializeEnum (7,0);
// Serialize systemInfoValueTag
SerializeInteger (0,0,31);
}
void
RrcAsn1Header::SerializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const
{
// 9 optional fields. Extension marker yes.
std::bitset<9> rrCfgCmmOpts;
rrCfgCmmOpts.set (8,1); // rach-ConfigCommon is present
rrCfgCmmOpts.set (7,0); // pdsch-ConfigCommon not present
rrCfgCmmOpts.set (6,0); // phich-Config not present
rrCfgCmmOpts.set (5,0); // pucch-ConfigCommon not present
rrCfgCmmOpts.set (4,0); // soundingRS-UL-ConfigCommon not present
rrCfgCmmOpts.set (3,0); // uplinkPowerControlCommon not present
rrCfgCmmOpts.set (2,0); // antennaInfoCommon not present
rrCfgCmmOpts.set (1,0); // p-Max not present
rrCfgCmmOpts.set (0,0); // tdd-Config not present
SerializeSequence (rrCfgCmmOpts,true);
if (rrCfgCmmOpts[8])
{
// Serialize RACH-ConfigCommon
SerializeRachConfigCommon (radioResourceConfigCommon.rachConfigCommon);
}
// Serialize PRACH-Config
// 1 optional, 0 extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Serialize PRACH-Config rootSequenceIndex
SerializeInteger (0,0,1023);
// Serialize PUSCH-ConfigCommon
SerializeSequence (std::bitset<0> (),false);
// Serialize pusch-ConfigBasic
SerializeSequence (std::bitset<0> (),false);
SerializeInteger (1,1,4);
SerializeEnum (2,0);
SerializeInteger (0,0,98);
SerializeBoolean (false);
// Serialize UL-ReferenceSignalsPUSCH
SerializeSequence (std::bitset<0> (),false);
SerializeBoolean (false);
SerializeInteger (0,0,29);
SerializeBoolean (false);
SerializeInteger (4,0,7);
// Serialize UL-CyclicPrefixLength
SerializeEnum (2,0);
}
void
RrcAsn1Header::SerializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const
{
SerializeSequence (std::bitset<0> (0),true);
// rach-ConfigCommon
SerializeRachConfigCommon (radioResourceConfigCommonSib.rachConfigCommon);
// bcch-Config
SerializeSequence (std::bitset<0> (0),false);
SerializeEnum (4,0); // modificationPeriodCoeff
// pcch-Config
SerializeSequence (std::bitset<0> (0),false);
SerializeEnum (4,0); // defaultPagingCycle
SerializeEnum (8,0); // nB
// prach-Config
SerializeSequence (std::bitset<1> (0),false);
SerializeInteger (0,0,1023); // rootSequenceIndex
// pdsch-ConfigCommon
SerializeSequence (std::bitset<0> (0),false);
SerializeInteger (0,-60,50); // referenceSignalPower
SerializeInteger (0,0,3); // p-b
// pusch-ConfigCommon
SerializeSequence (std::bitset<0> (0),false);
SerializeSequence (std::bitset<0> (0),false); // pusch-ConfigBasic
SerializeInteger (1,1,4); // n-SB
SerializeEnum (2,0); // hoppingMode
SerializeInteger (0,0,98); // pusch-HoppingOffset
SerializeBoolean (false); // enable64QAM
SerializeSequence (std::bitset<0> (0),false); // UL-ReferenceSignalsPUSCH
SerializeBoolean (false); // groupHoppingEnabled
SerializeInteger (0,0,29); // groupAssignmentPUSCH
SerializeBoolean (false); // sequenceHoppingEnabled
SerializeInteger (0,0,7); // cyclicShift
// pucch-ConfigCommon
SerializeSequence (std::bitset<0> (0),false);
SerializeEnum (3,0); // deltaPUCCH-Shift
SerializeInteger (0,0,98); // nRB-CQI
SerializeInteger (0,0,7); // nCS-AN
SerializeInteger (0,0,2047); // n1PUCCH-AN
// soundingRS-UL-ConfigCommon
SerializeChoice (2,0,false);
SerializeNull (); // release
// uplinkPowerControlCommon
SerializeSequence (std::bitset<0> (0),false);
SerializeInteger (0,-126,24); // p0-NominalPUSCH
SerializeEnum (8,0); // alpha
SerializeInteger (-50,-127,-96); // p0-NominalPUCCH
SerializeSequence (std::bitset<0> (0),false); // deltaFList-PUCCH
SerializeEnum (3,0); // deltaF-PUCCH-Format1
SerializeEnum (3,0); // deltaF-PUCCH-Format1b
SerializeEnum (4,0); // deltaF-PUCCH-Format2
SerializeEnum (3,0); // deltaF-PUCCH-Format2a
SerializeEnum (3,0); // deltaF-PUCCH-Format2b
SerializeInteger (0,-1,6);
// ul-CyclicPrefixLength
SerializeEnum (2,0);
}
void
RrcAsn1Header::SerializeSystemInformationBlockType2 (LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2) const
{
SerializeSequence (std::bitset<2> (0),true);
// RadioResourceConfigCommonSib
SerializeRadioResourceConfigCommonSib (systemInformationBlockType2.radioResourceConfigCommon);
// ue-TimersAndConstants
SerializeSequence (std::bitset<0> (0),true);
SerializeEnum (8,0); // t300
SerializeEnum (8,0); // t301
SerializeEnum (7,0); // t310
SerializeEnum (8,0); // n310
SerializeEnum (7,0); // t311
SerializeEnum (8,0); // n311
// freqInfo
SerializeSequence (std::bitset<2> (3),false);
SerializeInteger ((int) systemInformationBlockType2.freqInfo.ulCarrierFreq, 0, MAX_EARFCN);
switch (systemInformationBlockType2.freqInfo.ulBandwidth)
{
case 6:
SerializeEnum (6,0);
break;
case 15:
SerializeEnum (6,1);
break;
case 25:
SerializeEnum (6,2);
break;
case 50:
SerializeEnum (6,3);
break;
case 75:
SerializeEnum (6,4);
break;
case 100:
SerializeEnum (6,5);
break;
default:
SerializeEnum (6,0);
}
SerializeInteger (29,1,32); // additionalSpectrumEmission
// timeAlignmentTimerCommon
SerializeEnum (8,0);
}
void
RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults) const
{
// Watchdog: if list has 0 elements, set boolean to false
if (measResults.measResultListEutra.empty ())
{
measResults.haveMeasResultNeighCells = false;
}
std::bitset<4> measResultOptional;
measResultOptional.set (3, measResults.haveScellsMeas);
measResultOptional.set (2, false); //LocationInfo-r10
measResultOptional.set (1, false); // MeasResultForECID-r9
measResultOptional.set (0, measResults.haveMeasResultNeighCells);
SerializeSequence(measResultOptional,true);
// Serialize measId
SerializeInteger (measResults.measId,1,MAX_MEAS_ID);
// Serialize measResultServCell sequence
SerializeSequence (std::bitset<0> (0),false);
// Serialize rsrpResult
SerializeInteger (measResults.rsrpResult,0,97);
// Serialize rsrqResult
SerializeInteger (measResults.rsrqResult,0,34);
if (measResults.haveMeasResultNeighCells)
{
// Serialize Choice = 0 (MeasResultListEUTRA)
SerializeChoice (4,0,false);
// Serialize measResultNeighCells
SerializeSequenceOf (measResults.measResultListEutra.size (),MAX_CELL_REPORT,1);
// serialize MeasResultEutra elements in the list
std::list<LteRrcSap::MeasResultEutra>::iterator it;
for (it = measResults.measResultListEutra.begin (); it != measResults.measResultListEutra.end (); it++)
{
SerializeSequence (std::bitset<1> (it->haveCgiInfo),false);
// Serialize PhysCellId
SerializeInteger (it->physCellId, 0, 503);
// Serialize CgiInfo
if (it->haveCgiInfo)
{
SerializeSequence (std::bitset<1> (it->cgiInfo.plmnIdentityList.size ()),false);
// Serialize cellGlobalId
SerializeSequence (std::bitset<0> (0),false);
SerializePlmnIdentity (it->cgiInfo.plmnIdentity);
SerializeBitstring (std::bitset<28> (it->cgiInfo.cellIdentity));
// Serialize trackingAreaCode
SerializeBitstring (std::bitset<16> (it->cgiInfo.trackingAreaCode));
// Serialize plmn-IdentityList
if (!it->cgiInfo.plmnIdentityList.empty ())
{
SerializeSequenceOf (it->cgiInfo.plmnIdentityList.size (),5,1);
std::list<uint32_t>::iterator it2;
for (it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it->cgiInfo.plmnIdentityList.end (); it2++)
{
SerializePlmnIdentity (*it2);
}
}
}
// Serialize measResult
std::bitset<2> measResultFieldsPresent;
measResultFieldsPresent[1] = it->haveRsrpResult;
measResultFieldsPresent[0] = it->haveRsrqResult;
SerializeSequence (measResultFieldsPresent,true);
if (it->haveRsrpResult)
{
SerializeInteger (it->rsrpResult,0,97);
}
if (it->haveRsrqResult)
{
SerializeInteger (it->rsrqResult,0,34);
}
}
}
if (measResults.haveScellsMeas)
{
// Serialize measResultNeighCells
SerializeSequenceOf (measResults.measScellResultList.measResultScell.size (),MAX_SCELL_REPORT,1);
// serialize MeasResultServFreqList-r10 elements in the list
std::list<LteRrcSap::MeasResultScell>::iterator it;
for (it = measResults.measScellResultList.measResultScell.begin (); it != measResults.measScellResultList.measResultScell.end (); it++)
{
// Serialize measId
SerializeInteger (it->servFreqId,0,MAX_MEAS_ID); // ToDo: change with FreqId, currently is the componentCarrierId
// Serialize MeasResultServFreqList
std::bitset<2> measResultScellPresent;
measResultScellPresent[0] = measResults.measScellResultList.haveMeasurementResultsServingSCells;
measResultScellPresent[1] = measResults.measScellResultList.haveMeasurementResultsNeighCell; // Not implemented
SerializeSequence (measResultScellPresent,true);
// Serialize measResult
std::bitset<2> measResultScellFieldsPresent;
measResultScellFieldsPresent[1] = it->haveRsrpResult;
measResultScellFieldsPresent[0] = it->haveRsrqResult;
SerializeSequence (measResultScellFieldsPresent,true);
if (it->haveRsrpResult)
{
SerializeInteger (it->rsrpResult,0,97);
}
if (it->haveRsrqResult)
{
SerializeInteger (it->rsrqResult,0,34);
}
}
}
}
void
RrcAsn1Header::SerializePlmnIdentity (uint32_t plmnId) const
{
// plmn-Identity sequence, mcc is optional, no extension marker
SerializeSequence (std::bitset<1> (0), false);
// Serialize mnc
int nDig = (plmnId > 99) ? 3 : 2;
SerializeSequenceOf (nDig,3,2);
for (int i = nDig - 1; i >= 0; i--)
{
int n = floor (plmnId / pow (10,i));
SerializeInteger (n,0,9);
plmnId -= n * pow (10,i);
}
// cellReservedForOperatorUse
SerializeEnum (2,0);
}
void
RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfigCommon) const
{
// rach-ConfigCommon
SerializeSequence (std::bitset<0> (0),true);
// preambleInfo
SerializeSequence (std::bitset<1> (0),false);
// numberOfRA-Preambles
switch (rachConfigCommon.preambleInfo.numberOfRaPreambles)
{
case 4:
SerializeEnum (16,0);
break;
case 8:
SerializeEnum (16,1);
break;
case 12:
SerializeEnum (16,2);
break;
case 16:
SerializeEnum (16,3);
break;
case 20:
SerializeEnum (16,4);
break;
case 24:
SerializeEnum (16,5);
break;
case 28:
SerializeEnum (16,6);
break;
case 32:
SerializeEnum (16,7);
break;
case 36:
SerializeEnum (16,8);
break;
case 40:
SerializeEnum (16,9);
break;
case 44:
SerializeEnum (16,10);
break;
case 48:
SerializeEnum (16,11);
break;
case 52:
SerializeEnum (16,12);
break;
case 56:
SerializeEnum (16,13);
break;
case 60:
SerializeEnum (16,14);
break;
case 64:
SerializeEnum (16,15);
break;
default:
SerializeEnum (16,0);
}
SerializeSequence (std::bitset<0> (0),false); // powerRampingParameters
SerializeEnum (4,0); // powerRampingStep
SerializeEnum (16,0); // preambleInitialReceivedTargetPower
SerializeSequence (std::bitset<0> (0),false); // ra-SupervisionInfo
// preambleTransMax
switch (rachConfigCommon.raSupervisionInfo.preambleTransMax)
{
case 3:
SerializeEnum (11,0);
break;
case 4:
SerializeEnum (11,1);
break;
case 5:
SerializeEnum (11,2);
break;
case 6:
SerializeEnum (11,3);
break;
case 7:
SerializeEnum (11,4);
break;
case 8:
SerializeEnum (11,5);
break;
case 10:
SerializeEnum (11,6);
break;
case 20:
SerializeEnum (11,7);
break;
case 50:
SerializeEnum (11,8);
break;
case 100:
SerializeEnum (11,9);
break;
case 200:
SerializeEnum (11,10);
break;
default:
SerializeEnum (11,0);
}
// ra-ResponseWindowSize
switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize)
{
case 2:
SerializeEnum (8,0);
break;
case 3:
SerializeEnum (8,1);
break;
case 4:
SerializeEnum (8,2);
break;
case 5:
SerializeEnum (8,3);
break;
case 6:
SerializeEnum (8,4);
break;
case 7:
SerializeEnum (8,5);
break;
case 8:
SerializeEnum (8,6);
break;
case 10:
SerializeEnum (8,7);
break;
default:
SerializeEnum (8,0);
}
SerializeEnum (8,0); // mac-ContentionResolutionTimer
SerializeInteger (1,1,8); // maxHARQ-Msg3Tx
}
void
RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const
{
switch (qOffsetRange)
{
case -24:
SerializeEnum (31,0);
break;
case -22:
SerializeEnum (31,1);
break;
case -20:
SerializeEnum (31,2);
break;
case -18:
SerializeEnum (31,3);
break;
case -16:
SerializeEnum (31,4);
break;
case -14:
SerializeEnum (31,5);
break;
case -12:
SerializeEnum (31,6);
break;
case -10:
SerializeEnum (31,7);
break;
case -8:
SerializeEnum (31,8);
break;
case -6:
SerializeEnum (31,9);
break;
case -5:
SerializeEnum (31,10);
break;
case -4:
SerializeEnum (31,11);
break;
case -3:
SerializeEnum (31,12);
break;
case -2:
SerializeEnum (31,13);
break;
case -1:
SerializeEnum (31,14);
break;
case 0:
SerializeEnum (31,15);
break;
case 1:
SerializeEnum (31,16);
break;
case 2:
SerializeEnum (31,17);
break;
case 3:
SerializeEnum (31,18);
break;
case 4:
SerializeEnum (31,19);
break;
case 5:
SerializeEnum (31,20);
break;
case 6:
SerializeEnum (31,21);
break;
case 8:
SerializeEnum (31,22);
break;
case 10:
SerializeEnum (31,23);
break;
case 12:
SerializeEnum (31,24);
break;
case 14:
SerializeEnum (31,25);
break;
case 16:
SerializeEnum (31,26);
break;
case 18:
SerializeEnum (31,27);
break;
case 20:
SerializeEnum (31,28);
break;
case 22:
SerializeEnum (31,29);
break;
case 24:
SerializeEnum (31,30);
break;
default:
SerializeEnum (31,15);
}
}
void
RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const
{
switch (thresholdEutra.choice)
{
case LteRrcSap::ThresholdEutra::THRESHOLD_RSRP:
SerializeChoice (2,0,false);
SerializeInteger (thresholdEutra.range, 0, 97);
break;
case LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ:
default:
SerializeChoice (2,1,false);
SerializeInteger (thresholdEutra.range, 0, 34);
}
}
void
RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const
{
// Serialize MeasConfig sequence
// 11 optional fields, extension marker present
std::bitset<11> measConfigOptional;
measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () );
measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () );
measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () );
measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () );
measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () );
measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () );
measConfigOptional.set (4, measConfig.haveQuantityConfig );
measConfigOptional.set (3, measConfig.haveMeasGapConfig );
measConfigOptional.set (2, measConfig.haveSmeasure );
measConfigOptional.set (1, false ); // preRegistrationInfoHRPD
measConfigOptional.set (0, measConfig.haveSpeedStatePars );
SerializeSequence (measConfigOptional,true);
if (!measConfig.measObjectToRemoveList.empty ())
{
SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_ID,1);
for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList.begin (); it != measConfig.measObjectToRemoveList.end (); it++)
{
SerializeInteger (*it, 1, MAX_OBJECT_ID);
}
}
if (!measConfig.measObjectToAddModList.empty ())
{
SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_ID,1);
for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = measConfig.measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); it++)
{
SerializeSequence (std::bitset<0> (), false);
SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
SerializeChoice (4, 0, true); // Select MeasObjectEUTRA
// Serialize measObjectEutra
std::bitset<5> measObjOpts;
measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () );
measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () );
measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty () );
measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty () );
measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI);
SerializeSequence (measObjOpts, true);
// Serialize carrierFreq
SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN);
// Serialize allowedMeasBandwidth
switch (it->measObjectEutra.allowedMeasBandwidth)
{
case 6:
SerializeEnum (6,0);
break;
case 15:
SerializeEnum (6,1);
break;
case 25:
SerializeEnum (6,2);
break;
case 50:
SerializeEnum (6,3);
break;
case 75:
SerializeEnum (6,4);
break;
case 100:
SerializeEnum (6,5);
break;
default:
SerializeEnum (6,0);
}
SerializeBoolean (it->measObjectEutra.presenceAntennaPort1);
SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfig));
SerializeQoffsetRange (it->measObjectEutra.offsetFreq);
if (!it->measObjectEutra.cellsToRemoveList.empty ())
{
SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size (),MAX_CELL_MEAS,1);
for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++)
{
SerializeInteger (*it2, 1, MAX_CELL_MEAS);
}
}
if (!it->measObjectEutra.cellsToAddModList.empty ())
{
SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size (), MAX_CELL_MEAS, 1);
for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 = it->measObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModList.end (); it2++)
{
SerializeSequence (std::bitset<0> (), false);
// Serialize cellIndex
SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
// Serialize PhysCellId
SerializeInteger (it2->physCellId,0,503);
// Serialize cellIndividualOffset
SerializeQoffsetRange (it2->cellIndividualOffset);
}
}
if (!it->measObjectEutra.blackCellsToRemoveList.empty () )
{
SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.size (),MAX_CELL_MEAS,1);
for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.blackCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end (); it2++)
{
SerializeInteger (*it2, 1, MAX_CELL_MEAS);
}
}
if (!it->measObjectEutra.blackCellsToAddModList.empty () )
{
SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.size (), MAX_CELL_MEAS, 1);
for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = it->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blackCellsToAddModList.end (); it2++)
{
SerializeSequence (std::bitset<0> (),false);
SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
// Serialize PhysCellIdRange
// range optional
std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdRange.haveRange);
SerializeSequence (rangePresent,false);
SerializeInteger (it2->physCellIdRange.start,0,503);
if (it2->physCellIdRange.haveRange)
{
switch (it2->physCellIdRange.range)
{
case 4:
SerializeEnum (16, 0);
break;
case 8:
SerializeEnum (16, 1);
break;
case 12:
SerializeEnum (16, 2);
break;
case 16:
SerializeEnum (16, 3);
break;
case 24:
SerializeEnum (16, 4);
break;
case 32:
SerializeEnum (16, 5);
break;
case 48:
SerializeEnum (16, 6);
break;
case 64:
SerializeEnum (16, 7);
break;
case 84:
SerializeEnum (16, 8);
break;
case 96:
SerializeEnum (16, 9);
break;
case 128:
SerializeEnum (16, 10);
break;
case 168:
SerializeEnum (16, 11);
break;
case 252:
SerializeEnum (16, 12);
break;
case 504:
SerializeEnum (16, 13);
break;
default:
SerializeEnum (16, 0);
}
}
}
}
if (it->measObjectEutra.haveCellForWhichToReportCGI)
{
SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,503);
}
}
}
if (!measConfig.reportConfigToRemoveList.empty () )
{
SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPORT_CONFIG_ID,1);
for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveList.begin (); it != measConfig.reportConfigToRemoveList.end (); it++)
{
SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID);
}
}
if (!measConfig.reportConfigToAddModList.empty () )
{
SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPORT_CONFIG_ID,1);
for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = measConfig.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end (); it++)
{
SerializeSequence (std::bitset<0> (), false);
SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID);
SerializeChoice (2,0,false); // reportConfigEUTRA
// Serialize ReportConfigEUTRA
SerializeSequence (std::bitset<0> (), true);
switch (it->reportConfigEutra.triggerType)
{
case LteRrcSap::ReportConfigEutra::PERIODICAL:
SerializeChoice (2, 1, false);
SerializeSequence (std::bitset<0> (),false);
switch (it->reportConfigEutra.purpose)
{
case LteRrcSap::ReportConfigEutra::REPORT_CGI:
SerializeEnum (2,1);
break;
case LteRrcSap::ReportConfigEutra::REPORT_STRONGEST_CELLS:
default:
SerializeEnum (2,0);
}
break;
case LteRrcSap::ReportConfigEutra::EVENT:
default:
SerializeChoice (2, 0, false);
SerializeSequence (std::bitset<0> (),false);
switch (it->reportConfigEutra.eventId)
{
case LteRrcSap::ReportConfigEutra::EVENT_A1:
SerializeChoice (5, 0, true);
SerializeSequence (std::bitset<0> (),false);
SerializeThresholdEutra (it->reportConfigEutra.threshold1);
break;
case LteRrcSap::ReportConfigEutra::EVENT_A2:
SerializeChoice (5, 1, true);
SerializeSequence (std::bitset<0> (),false);
SerializeThresholdEutra (it->reportConfigEutra.threshold1);
break;
case LteRrcSap::ReportConfigEutra::EVENT_A3:
SerializeChoice (5, 2, true);
SerializeSequence (std::bitset<0> (),false);
SerializeInteger (it->reportConfigEutra.a3Offset,-30,30);
SerializeBoolean (it->reportConfigEutra.reportOnLeave);
break;
case LteRrcSap::ReportConfigEutra::EVENT_A4:
SerializeChoice (5, 3, true);
SerializeSequence (std::bitset<0> (),false);
SerializeThresholdEutra (it->reportConfigEutra.threshold1);
break;
case LteRrcSap::ReportConfigEutra::EVENT_A5:
default:
SerializeChoice (5, 4, true);
SerializeSequence (std::bitset<0> (),false);
SerializeThresholdEutra (it->reportConfigEutra.threshold1);
SerializeThresholdEutra (it->reportConfigEutra.threshold2);
}
SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30);
switch (it->reportConfigEutra.timeToTrigger)
{
case 0:
SerializeEnum (16, 0);
break;
case 40:
SerializeEnum (16, 1);
break;
case 64:
SerializeEnum (16, 2);
break;
case 80:
SerializeEnum (16, 3);
break;
case 100:
SerializeEnum (16, 4);
break;
case 128:
SerializeEnum (16, 5);
break;
case 160:
SerializeEnum (16, 6);
break;
case 256:
SerializeEnum (16, 7);
break;
case 320:
SerializeEnum (16, 8);
break;
case 480:
SerializeEnum (16, 9);
break;
case 512:
SerializeEnum (16, 10);
break;
case 640:
SerializeEnum (16, 11);
break;
case 1024:
SerializeEnum (16, 12);
break;
case 1280:
SerializeEnum (16, 13);
break;
case 2560:
SerializeEnum (16, 14);
break;
case 5120:
default:
SerializeEnum (16, 15);
}
} // end trigger type
// Serialize triggerQuantity
if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::RSRP)
{
SerializeEnum (2, 0);
}
else
{
SerializeEnum (2, 1);
}
// Serialize reportQuantity
if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEutra::SAME_AS_TRIGGER_QUANTITY)
{
SerializeEnum (2, 0);
}
else
{
SerializeEnum (2, 1);
}
// Serialize maxReportCells
SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT);
// Serialize reportInterval
switch (it->reportConfigEutra.reportInterval)
{
case LteRrcSap::ReportConfigEutra::MS120:
SerializeEnum (16, 0);
break;
case LteRrcSap::ReportConfigEutra::MS240:
SerializeEnum (16, 1);
break;
case LteRrcSap::ReportConfigEutra::MS480:
SerializeEnum (16, 2);
break;
case LteRrcSap::ReportConfigEutra::MS640:
SerializeEnum (16, 3);
break;
case LteRrcSap::ReportConfigEutra::MS1024:
SerializeEnum (16, 4);
break;
case LteRrcSap::ReportConfigEutra::MS2048:
SerializeEnum (16, 5);
break;
case LteRrcSap::ReportConfigEutra::MS5120:
SerializeEnum (16, 6);
break;
case LteRrcSap::ReportConfigEutra::MS10240:
SerializeEnum (16, 7);
break;
case LteRrcSap::ReportConfigEutra::MIN1:
SerializeEnum (16, 8);
break;
case LteRrcSap::ReportConfigEutra::MIN6:
SerializeEnum (16, 9);
break;
case LteRrcSap::ReportConfigEutra::MIN12:
SerializeEnum (16, 10);
break;
case LteRrcSap::ReportConfigEutra::MIN30:
SerializeEnum (16, 11);
break;
case LteRrcSap::ReportConfigEutra::MIN60:
SerializeEnum (16, 12);
break;
case LteRrcSap::ReportConfigEutra::SPARE3:
SerializeEnum (16, 13);
break;
case LteRrcSap::ReportConfigEutra::SPARE2:
SerializeEnum (16, 14);
break;
case LteRrcSap::ReportConfigEutra::SPARE1:
default:
SerializeEnum (16, 15);
}
// Serialize reportAmount
switch (it->reportConfigEutra.reportAmount)
{
case 1:
SerializeEnum (8, 0);
break;
case 2:
SerializeEnum (8, 1);
break;
case 4:
SerializeEnum (8, 2);
break;
case 8:
SerializeEnum (8, 3);
break;
case 16:
SerializeEnum (8, 4);
break;
case 32:
SerializeEnum (8, 5);
break;
case 64:
SerializeEnum (8, 6);
break;
default:
SerializeEnum (8, 7);
}
}
}
if (!measConfig.measIdToRemoveList.empty () )
{
SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1);
for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.begin (); it != measConfig.measIdToRemoveList.end (); it++)
{
SerializeInteger (*it, 1, MAX_MEAS_ID);
}
}
if (!measConfig.measIdToAddModList.empty () )
{
SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID, 1);
for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it = measConfig.measIdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++)
{
SerializeInteger (it->measId, 1, MAX_MEAS_ID);
SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
}
}
if (measConfig.haveQuantityConfig )
{
// QuantityConfig sequence
// 4 optional fields, only first (EUTRA) present. Extension marker yes.
std::bitset<4> quantityConfigOpts (0);
quantityConfigOpts.set (3,1);
SerializeSequence (quantityConfigOpts, true);
SerializeSequence (std::bitset<0> (), false);
switch (measConfig.quantityConfig.filterCoefficientRSRP)
{
case 0:
SerializeEnum (16, 0);
break;
case 1:
SerializeEnum (16, 1);
break;
case 2:
SerializeEnum (16, 2);
break;
case 3:
SerializeEnum (16, 3);
break;
case 4:
SerializeEnum (16, 4);
break;
case 5:
SerializeEnum (16, 5);
break;
case 6:
SerializeEnum (16, 6);
break;
case 7:
SerializeEnum (16, 7);
break;
case 8:
SerializeEnum (16, 8);
break;
case 9:
SerializeEnum (16, 9);
break;
case 11:
SerializeEnum (16, 10);
break;
case 13:
SerializeEnum (16, 11);
break;
case 15:
SerializeEnum (16, 12);
break;
case 17:
SerializeEnum (16, 13);
break;
case 19:
SerializeEnum (16, 14);
break;
default:
SerializeEnum (16, 4);
}
switch (measConfig.quantityConfig.filterCoefficientRSRQ)
{
case 0:
SerializeEnum (16, 0);
break;
case 1:
SerializeEnum (16, 1);
break;
case 2:
SerializeEnum (16, 2);
break;
case 3:
SerializeEnum (16, 3);
break;
case 4:
SerializeEnum (16, 4);
break;
case 5:
SerializeEnum (16, 5);
break;
case 6:
SerializeEnum (16, 6);
break;
case 7:
SerializeEnum (16, 7);
break;
case 8:
SerializeEnum (16, 8);
break;
case 9:
SerializeEnum (16, 9);
break;
case 11:
SerializeEnum (16, 10);
break;
case 13:
SerializeEnum (16, 11);
break;
case 15:
SerializeEnum (16, 12);
break;
case 17:
SerializeEnum (16, 13);
break;
case 19:
SerializeEnum (16, 14);
break;
default:
SerializeEnum (16, 4);
}
}
if (measConfig.haveMeasGapConfig )
{
switch (measConfig.measGapConfig.type)
{
case LteRrcSap::MeasGapConfig::RESET:
SerializeChoice (2, 0, false);
SerializeNull ();
break;
case LteRrcSap::MeasGapConfig::SETUP:
default:
SerializeChoice (2, 1, false);
SerializeSequence (std::bitset<0> (),false);
switch (measConfig.measGapConfig.gapOffsetChoice)
{
case LteRrcSap::MeasGapConfig::GP0:
SerializeChoice (2, 0, true);
SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39);
break;
case LteRrcSap::MeasGapConfig::GP1:
default:
SerializeChoice (2, 1, true);
SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79);
}
}
}
if (measConfig.haveSmeasure )
{
SerializeInteger (measConfig.sMeasure, 0, 97);
}
// ...Here preRegistrationInfoHRPD would be serialized
if (measConfig.haveSpeedStatePars )
{
switch (measConfig.speedStatePars.type)
{
case LteRrcSap::SpeedStatePars::RESET:
SerializeChoice (2, 0, false);
SerializeNull ();
break;
case LteRrcSap::SpeedStatePars::SETUP:
default:
SerializeChoice (2, 1, false);
SerializeSequence (std::bitset<0> (), false);
switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation)
{
case 30:
SerializeEnum (8, 0);
break;
case 60:
SerializeEnum (8, 1);
break;
case 120:
SerializeEnum (8, 2);
break;
case 180:
SerializeEnum (8, 3);
break;
case 240:
SerializeEnum (8, 4);
break;
default:
SerializeEnum (8, 5);
break;
}
switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal)
{
case 30:
SerializeEnum (8, 0);
break;
case 60:
SerializeEnum (8, 1);
break;
case 120:
SerializeEnum (8, 2);
break;
case 180:
SerializeEnum (8, 3);
break;
case 240:
SerializeEnum (8, 4);
break;
default:
SerializeEnum (8, 5);
break;
}
SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium, 1, 16);
SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh, 1, 16);
SerializeSequence (std::bitset<0> (), false);
switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium)
{
case 25:
SerializeEnum (4, 0);
break;
case 50:
SerializeEnum (4, 1);
break;
case 75:
SerializeEnum (4, 2);
break;
case 100:
default:
SerializeEnum (4, 3);
}
switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh)
{
case 25:
SerializeEnum (4, 0);
break;
case 50:
SerializeEnum (4, 1);
break;
case 75:
SerializeEnum (4, 2);
break;
case 100:
default:
SerializeEnum (4, 3);
}
}
}
}
void
RrcAsn1Header::SerializeNonCriticalExtensionConfiguration (LteRrcSap::NonCriticalExtensionConfiguration nonCriticalExtension) const
{
// 3 optional fields. Extension marker not present.
std::bitset<3> noncriticalExtension_v1020;
noncriticalExtension_v1020.set (1,0); // No sCellToRealeaseList-r10
noncriticalExtension_v1020.set (1,1); // sCellToAddModList-r10
noncriticalExtension_v1020.set (0,0); // No nonCriticalExtension RRCConnectionReconfiguration-v1130-IEs
SerializeSequence (noncriticalExtension_v1020,false);
if (!nonCriticalExtension.sCellsToAddModList.empty ())
{
SerializeSequenceOf (nonCriticalExtension.sCellsToAddModList.size (),MAX_OBJECT_ID,1);
for (std::list<LteRrcSap::SCellToAddMod>::iterator it = nonCriticalExtension.sCellsToAddModList.begin (); it != nonCriticalExtension.sCellsToAddModList.end (); it++)
{
std::bitset<4> sCellToAddMod_r10;
sCellToAddMod_r10.set (3,1); // sCellIndex
sCellToAddMod_r10.set (2,1); // CellIdentification
sCellToAddMod_r10.set (1,1); // RadioResourceConfigCommonSCell
sCellToAddMod_r10.set (0,it->haveRadioResourceConfigDedicatedSCell); // No nonCriticalExtension RRC
SerializeSequence (sCellToAddMod_r10, false);
SerializeInteger (it->sCellIndex,1,MAX_OBJECT_ID); //sCellIndex
// Serialize CellIdentification
std::bitset<2> cellIdentification_r10;
cellIdentification_r10.set(1,1); // phyCellId-r10
cellIdentification_r10.set(0,1); // dl-CarrierFreq-r10
SerializeSequence (cellIdentification_r10, false);
SerializeInteger (it->cellIdentification.physCellId,1,MAX_EARFCN);
SerializeInteger (it->cellIdentification.dlCarrierFreq,1,MAX_EARFCN);
//Serialize RadioResourceConfigCommonSCell
SerializeRadioResourceConfigCommonSCell (it->radioResourceConfigCommonSCell);
if (it->haveRadioResourceConfigDedicatedSCell)
{
//Serialize RadioResourceConfigDedicatedSCell
SerializeRadioResourceDedicatedSCell (it->radioResourceConfigDedicateSCell);
}
}
}
else
{
// NS_ASSERT_MSG ( this << "NonCriticalExtension.sCellsToAddModList cannot be empty ", false);
}
}
void
RrcAsn1Header::SerializeRadioResourceConfigCommonSCell (LteRrcSap::RadioResourceConfigCommonSCell rrccsc) const
{
// 2 optional fields. Extension marker not present.
std::bitset<2> radioResourceConfigCommonSCell_r10;
radioResourceConfigCommonSCell_r10.set (1,rrccsc.haveNonUlConfiguration); // NonUlConfiguration
radioResourceConfigCommonSCell_r10.set (0,rrccsc.haveUlConfiguration); // UlConfiguration
SerializeSequence (radioResourceConfigCommonSCell_r10,false);
if (radioResourceConfigCommonSCell_r10[1])
{
// 5 optional fields. Extension marker not present.
std::bitset<5> nonUlConfiguration_r10;
nonUlConfiguration_r10.set (4,1); // Dl- bandwidth --> convert in enum
nonUlConfiguration_r10.set (3,1); // AntennaInfoCommon-r10
nonUlConfiguration_r10.set (2,0); // phich-Config-r10 Not Implemented
nonUlConfiguration_r10.set (1,1); // pdschConfigCommon
nonUlConfiguration_r10.set (0,0); // Tdd-Config-r10 Not Implemented
SerializeSequence (nonUlConfiguration_r10,false);
SerializeInteger (rrccsc.nonUlConfiguration.dlBandwidth,6,100);
std::bitset<1> antennaInfoCommon_r10;
antennaInfoCommon_r10.set (0,1);
SerializeSequence (antennaInfoCommon_r10,false);
SerializeInteger (rrccsc.nonUlConfiguration.antennaInfoCommon.antennaPortsCount,0,65536);
std::bitset<2> pdschConfigCommon_r10;
pdschConfigCommon_r10.set (1,1);
pdschConfigCommon_r10.set (0,1);
SerializeSequence (pdschConfigCommon_r10,false);
SerializeInteger (rrccsc.nonUlConfiguration.pdschConfigCommon.referenceSignalPower,-60,50);
SerializeInteger (rrccsc.nonUlConfiguration.pdschConfigCommon.pb,0,3);
}
if (radioResourceConfigCommonSCell_r10[0])
{
//Serialize Ul Configuration
// 7 optional fields. Extension marker present.
std::bitset<7> UlConfiguration_r10;
UlConfiguration_r10.set (6,1); // ul-Configuration-r10
UlConfiguration_r10.set (5,0); // p-Max-r10 Not Implemented
UlConfiguration_r10.set (4,1); // uplinkPowerControlCommonSCell-r10
UlConfiguration_r10.set (3,0); // soundingRS-UL-ConfigCommon-r10
UlConfiguration_r10.set (2,0); // ul-CyclicPrefixLength-r10
UlConfiguration_r10.set (1,1); // prach-ConfigSCell-r10
UlConfiguration_r10.set (0,0); // pusch-ConfigCommon-r10 Not Implemented
SerializeSequence (UlConfiguration_r10,true);
//Serialize ulFreqInfo
std::bitset<3> FreqInfo_r10;
FreqInfo_r10.set (2,1); // ulCarrierFreq
FreqInfo_r10.set (1,1); // UlBandwidth
FreqInfo_r10.set (0,0); // additionalSpectrumEmissionSCell-r10 Not Implemented
SerializeSequence (FreqInfo_r10,false);
SerializeInteger (rrccsc.ulConfiguration.ulFreqInfo.ulCarrierFreq,0,MAX_EARFCN);
SerializeInteger (rrccsc.ulConfiguration.ulFreqInfo.ulBandwidth,6,100);
//Serialize UlPowerControllCommonSCell
std::bitset<2> UlPowerControlCommonSCell_r10;
UlPowerControlCommonSCell_r10.set (1,0); // p0-NominalPUSCH-r10 Not Implemented
UlPowerControlCommonSCell_r10.set (0,1); // alpha
SerializeSequence (UlPowerControlCommonSCell_r10,false);
SerializeInteger (rrccsc.ulConfiguration.ulPowerControlCommonSCell.alpha,0,65536);
//Serialize soundingRs-UlConfigCommon
//Not Implemented
//Serialize PrachConfigSCell
std::bitset<1> prachConfigSCell_r10;
prachConfigSCell_r10.set(0,1);
SerializeSequence(prachConfigSCell_r10,false);
SerializeInteger (rrccsc.ulConfiguration.prachConfigSCell.index,0,256);
}
}
void
RrcAsn1Header::SerializeRadioResourceDedicatedSCell (LteRrcSap::RadioResourceConfigDedicatedSCell rrcdsc) const
{
//Serialize RadioResourceConfigDedicatedSCell
std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
RadioResourceConfigDedicatedSCell_r10.set (0,1);
SerializeSequence (RadioResourceConfigDedicatedSCell_r10,false);
LteRrcSap::PhysicalConfigDedicatedSCell pcdsc = rrcdsc.physicalConfigDedicatedSCell;
SerializePhysicalConfigDedicatedSCell (pcdsc);
}
void
RrcAsn1Header::SerializePhysicalConfigDedicatedSCell (LteRrcSap::PhysicalConfigDedicatedSCell pcdsc) const
{
std::bitset<2> pcdscOpt;
pcdscOpt.set (1,pcdsc.haveNonUlConfiguration);
pcdscOpt.set (0,pcdsc.haveUlConfiguration);
SerializeSequence (pcdscOpt, true);
if (pcdscOpt[1])
{
//Serialize NonUl configuration
std::bitset<4> nulOpt;
nulOpt.set (3,pcdsc.haveAntennaInfoDedicated);
nulOpt.set (2,0); // crossCarrierSchedulingConfig-r10 NOT IMplemented
nulOpt.set (1,0); // csi-RS-Config-r10 Not Implemented
nulOpt.set (0, pcdsc.havePdschConfigDedicated); // pdsch-ConfigDedicated-r10
SerializeSequence (nulOpt,false);
if (pcdsc.haveAntennaInfoDedicated)
{
// Serialize antennaInfo choice
// 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
SerializeChoice (2,0,false);
// Serialize AntennaInfoDedicated sequence
// 1 optional parameter, not present. No extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Serialize transmissionMode
// Assuming the value in the struct is the enum index
SerializeEnum (8,pcdsc.antennaInfo.transmissionMode);
// Serialize ue-TransmitAntennaSelection choice
SerializeChoice (2,0,false);
// Serialize release
SerializeNull ();
}
if (pcdsc.havePdschConfigDedicated)
{
// Serialize Pdsch-ConfigDedicated Sequence:
// 0 optional / default fields, no extension marker.
SerializeSequence (std::bitset<0> (),false);
// Serialize p-a
// Assuming the value in the struct is the enum index
SerializeEnum (8,pcdsc.pdschConfigDedicated.pa);
// Serialize release
SerializeNull ();
}
}
if (pcdscOpt[0])
{
//Serialize Ul Configuration
std::bitset<7> ulOpt;
ulOpt.set (6, pcdsc.haveAntennaInfoUlDedicated);// antennaInfoUL-r10
ulOpt.set (5,0); // pusch-ConfigDedicatedSCell-r10 not present
ulOpt.set (4,0); // uplinkPowerControlDedicatedSCell-r10 not present
ulOpt.set (3,0); // cqi-ReportConfigSCell-r10 not present
ulOpt.set (2,pcdsc.haveSoundingRsUlConfigDedicated);// soundingRS-UL-ConfigDedicated-r10
ulOpt.set (1,0); // soundingRS-UL-ConfigDedicated-v1020 not present
ulOpt.set (0,0); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present
SerializeSequence (ulOpt,false);
if (pcdsc.haveAntennaInfoUlDedicated)
{
// Serialize antennaInfo choice
// 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
SerializeChoice (2,0,false);
// Serialize AntennaInfoDedicated sequence
// 1 optional parameter, not present. No extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Serialize transmissionMode
// Assuming the value in the struct is the enum index
SerializeEnum (8,pcdsc.antennaInfoUl.transmissionMode);
// Serialize ue-TransmitAntennaSelection choice
SerializeChoice (2,0,false);
// Serialize release
SerializeNull ();
}
if (pcdsc.haveSoundingRsUlConfigDedicated)
{
// Serialize SoundingRS-UL-ConfigDedicated choice:
switch (pcdsc.soundingRsUlConfigDedicated.type)
{
case LteRrcSap::SoundingRsUlConfigDedicated::RESET:
SerializeChoice (2,0,false);
SerializeNull ();
break;
case LteRrcSap::SoundingRsUlConfigDedicated::SETUP:
default:
// 2 options, selected: 1 (setup)
SerializeChoice (2,1,false);
// Serialize setup sequence
// 0 optional / default fields, no extension marker.
SerializeSequence (std::bitset<0> (),false);
// Serialize srs-Bandwidth
SerializeEnum (4,pcdsc.soundingRsUlConfigDedicated.srsBandwidth);
// Serialize srs-HoppingBandwidth
SerializeEnum (4,0);
// Serialize freqDomainPosition
SerializeInteger (0,0,23);
// Serialize duration
SerializeBoolean (false);
// Serialize srs-ConfigIndex
SerializeInteger (pcdsc.soundingRsUlConfigDedicated.srsConfigIndex,0,1023);
// Serialize transmissionComb
SerializeInteger (0,0,1);
// Serialize cyclicShift
SerializeEnum (8,0);
break;
}
}
}
}
Buffer::Iterator
RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator)
{
int thresholdEutraChoice, range;
bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator);
switch (thresholdEutraChoice)
{
case 0:
thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
bIterator = DeserializeInteger (&range, 0, 97, bIterator);
thresholdEutra->range = range;
break;
case 1:
default:
thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ;
bIterator = DeserializeInteger (&range, 0, 34, bIterator);
thresholdEutra->range = range;
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator)
{
int n;
bIterator = DeserializeEnum (31, &n, bIterator);
switch (n)
{
case 0:
*qOffsetRange = -24;
break;
case 1:
*qOffsetRange = -22;
break;
case 2:
*qOffsetRange = -20;
break;
case 3:
*qOffsetRange = -18;
break;
case 4:
*qOffsetRange = -16;
break;
case 5:
*qOffsetRange = -14;
break;
case 6:
*qOffsetRange = -12;
break;
case 7:
*qOffsetRange = -10;
break;
case 8:
*qOffsetRange = -8;
break;
case 9:
*qOffsetRange = -6;
break;
case 10:
*qOffsetRange = -5;
break;
case 11:
*qOffsetRange = -4;
break;
case 12:
*qOffsetRange = -3;
break;
case 13:
*qOffsetRange = -2;
break;
case 14:
*qOffsetRange = -1;
break;
case 15:
*qOffsetRange = 0;
break;
case 16:
*qOffsetRange = 1;
break;
case 17:
*qOffsetRange = 2;
break;
case 18:
*qOffsetRange = 3;
break;
case 19:
*qOffsetRange = 4;
break;
case 20:
*qOffsetRange = 5;
break;
case 21:
*qOffsetRange = 6;
break;
case 22:
*qOffsetRange = 8;
break;
case 23:
*qOffsetRange = 10;
break;
case 24:
*qOffsetRange = 12;
break;
case 25:
*qOffsetRange = 14;
break;
case 26:
*qOffsetRange = 16;
break;
case 27:
*qOffsetRange = 18;
break;
case 28:
*qOffsetRange = 20;
break;
case 29:
*qOffsetRange = 22;
break;
case 30:
default:
*qOffsetRange = 24;
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator)
{
// Deserialize RadioResourceConfigDedicated sequence
std::bitset<6> optionalFieldsPresent = std::bitset<6> ();
bIterator = DeserializeSequence (&optionalFieldsPresent,true,bIterator);
if (optionalFieldsPresent[5])
{
// Deserialize srb-ToAddModList
bIterator = DeserializeSrbToAddModList (&(radioResourceConfigDedicated->srbToAddModList),bIterator);
}
if (optionalFieldsPresent[4])
{
// Deserialize drb-ToAddModList
bIterator = DeserializeDrbToAddModList (&(radioResourceConfigDedicated->drbToAddModList),bIterator);
}
if (optionalFieldsPresent[3])
{
// Deserialize drb-ToReleaseList
int n;
int val;
bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator);
for (int i = 0; i < n; i++)
{
bIterator = DeserializeInteger (&val,1,32,bIterator);
radioResourceConfigDedicated->drbToReleaseList.push_back (val);
}
}
if (optionalFieldsPresent[2])
{
// Deserialize mac-MainConfig
// ...
}
if (optionalFieldsPresent[1])
{
// Deserialize sps-Config
// ...
}
radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPresent[0];
if (optionalFieldsPresent[0])
{
// Deserialize physicalConfigDedicated
bIterator = DeserializePhysicalConfigDedicated (&radioResourceConfigDedicated->physicalConfigDedicated,bIterator);
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> *srbToAddModList, Buffer::Iterator bIterator)
{
int numElems;
bIterator = DeserializeSequenceOf (&numElems,2,1,bIterator);
srbToAddModList->clear ();
// Deserialize SRB-ToAddMod elements
for (int i = 0; i < numElems; i++)
{
LteRrcSap::SrbToAddMod srbToAddMod;
// Deserialize SRB-ToAddMod sequence
// 2 optional fields, extension marker present
std::bitset<2> optionalFields;
bIterator = DeserializeSequence (&optionalFields,true,bIterator);
// Deserialize srbIdentity
int n;
bIterator = DeserializeInteger (&n,1,2,bIterator);
srbToAddMod.srbIdentity = n;
if (optionalFields[1])
{
// Deserialize rlcConfig choice
// ...
}
if (optionalFields[0])
{
// Deserialize logicalChannelConfig choice
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
// Deserialize logicalChannelConfig defaultValue
if (sel == 1)
{
bIterator = DeserializeNull (bIterator);
}
// Deserialize logicalChannelConfig explicitValue
else if (sel == 0)
{
bIterator = DeserializeLogicalChannelConfig (&srbToAddMod.logicalChannelConfig,bIterator);
}
}
srbToAddModList->insert (srbToAddModList->end (),srbToAddMod);
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> *drbToAddModList, Buffer::Iterator bIterator)
{
int n;
int val;
bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator);
drbToAddModList->clear ();
for (int i = 0; i < n; i++)
{
LteRrcSap::DrbToAddMod drbToAddMod;
std::bitset<5> optionalFields;
bIterator = DeserializeSequence (&optionalFields,true,bIterator);
if (optionalFields[4])
{
// Deserialize epsBearerIdentity
bIterator = DeserializeInteger (&val,0,15,bIterator);
drbToAddMod.epsBearerIdentity = val;
}
bIterator = DeserializeInteger (&val,1,32,bIterator);
drbToAddMod.drbIdentity = val;
if (optionalFields[3])
{
// Deserialize pdcp-Config
// ...
}
if (optionalFields[2])
{
// Deserialize RLC-Config
int chosen;
bIterator = DeserializeChoice (4,true,&chosen,bIterator);
int sel;
std::bitset<0> bitset0;
switch (chosen)
{
case 0:
drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::AM;
// Deserialize UL-AM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (64,&sel, bIterator); // t-PollRetransmit
bIterator = DeserializeEnum (8,&sel, bIterator); // pollPDU
bIterator = DeserializeEnum (16,&sel, bIterator); // pollByte
bIterator = DeserializeEnum (8,&sel, bIterator); // maxRetxThreshold
// Deserialize DL-AM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering
bIterator = DeserializeEnum (64,&sel, bIterator); // t-StatusProhibit
break;
case 1:
drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL;
// Deserialize UL-UM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength
// Deserialize DL-UM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength
bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering
break;
case 2:
drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL;
// Deserialize UL-UM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength
break;
case 3:
drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL;
// Deserialize DL-UM-RLC
bIterator = DeserializeSequence (&bitset0,false, bIterator);
bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength
bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering
break;
}
}
if (optionalFields[1])
{
bIterator = DeserializeInteger (&val,3,10,bIterator);
drbToAddMod.logicalChannelIdentity = val;
}
if (optionalFields[0])
{
bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChannelConfig,bIterator);
}
drbToAddModList->insert (drbToAddModList->end (),drbToAddMod);
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig *logicalChannelConfig, Buffer::Iterator bIterator)
{
int n;
// Deserialize LogicalChannelConfig sequence
// 1 optional field, extension marker is present.
std::bitset<1> bitset1;
bIterator = DeserializeSequence (&bitset1,true,bIterator);
if (bitset1[0])
{
// Deserialize ul-SpecificParameters sequence
bIterator = DeserializeSequence (&bitset1,false,bIterator);
// Deserialize priority
bIterator = DeserializeInteger (&n,1,16,bIterator);
logicalChannelConfig->priority = n;
// Deserialize prioritisedBitRate
bIterator = DeserializeEnum (16,&n,bIterator);
uint16_t prioritizedBitRateKbps;
switch (n)
{
case 0:
prioritizedBitRateKbps = 0;
break;
case 1:
prioritizedBitRateKbps = 8;
break;
case 2:
prioritizedBitRateKbps = 16;
break;
case 3:
prioritizedBitRateKbps = 32;
break;
case 4:
prioritizedBitRateKbps = 64;
break;
case 5:
prioritizedBitRateKbps = 128;
break;
case 6:
prioritizedBitRateKbps = 256;
break;
case 7:
prioritizedBitRateKbps = 10000;
break;
default:
prioritizedBitRateKbps = 10000;
}
logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps;
// Deserialize bucketSizeDuration
bIterator = DeserializeEnum (8,&n,bIterator);
uint16_t bucketSizeDurationMs;
switch (n)
{
case 0:
bucketSizeDurationMs = 50;
break;
case 1:
bucketSizeDurationMs = 100;
break;
case 2:
bucketSizeDurationMs = 150;
break;
case 3:
bucketSizeDurationMs = 300;
break;
case 4:
bucketSizeDurationMs = 500;
break;
case 5:
bucketSizeDurationMs = 1000;
break;
default:
bucketSizeDurationMs = 1000;
}
logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs;
if (bitset1[0])
{
// Deserialize logicalChannelGroup
bIterator = DeserializeInteger (&n,0,3,bIterator);
logicalChannelConfig->logicalChannelGroup = n;
}
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedicated *physicalConfigDedicated, Buffer::Iterator bIterator)
{
std::bitset<10> optionalFieldPresent;
bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator);
physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9];
if (optionalFieldPresent[9])
{
// Deserialize pdsch-ConfigDedicated
std::bitset<0> bitset0;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
int slct;
// Deserialize p-a
bIterator = DeserializeEnum (8,&slct,bIterator);
physicalConfigDedicated->pdschConfigDedicated.pa = slct;
bIterator = DeserializeNull (bIterator);
}
if (optionalFieldPresent[8])
{
// Deserialize pucch-ConfigDedicated
// ...
}
if (optionalFieldPresent[7])
{
// Deserialize pusch-ConfigDedicated
// ...
}
if (optionalFieldPresent[6])
{
// Deserialize uplinkPowerControlDedicated
// ...
}
if (optionalFieldPresent[5])
{
// Deserialize tpc-PDCCH-ConfigPUCCH
// ...
}
if (optionalFieldPresent[4])
{
// Deserialize tpc-PDCCH-ConfigPUSCH
// ...
}
if (optionalFieldPresent[3])
{
// Deserialize cqi-ReportConfig
// ...
}
physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPresent[2];
if (optionalFieldPresent[2])
{
// Deserialize soundingRS-UL-ConfigDedicated
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 0)
{
physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::RESET;
bIterator = DeserializeNull (bIterator);
}
else if (sel == 1)
{
physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::SETUP;
std::bitset<0> bitset0;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
int slct;
// Deserialize srs-Bandwidth
bIterator = DeserializeEnum (4,&slct,bIterator);
physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = slct;
// Deserialize srs-HoppingBandwidth
bIterator = DeserializeEnum (4,&slct,bIterator);
// Deserialize freqDomainPosition
bIterator = DeserializeInteger (&slct,0,23,bIterator);
// Deserialize duration
bool duration;
bIterator = DeserializeBoolean (&duration,bIterator);
// Deserialize srs-ConfigIndex
bIterator = DeserializeInteger (&slct,0,1023,bIterator);
physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex = slct;
// Deserialize transmissionComb
bIterator = DeserializeInteger (&slct,0,1,bIterator);
// Deserialize cyclicShift
bIterator = DeserializeEnum (8,&slct,bIterator);
}
}
physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1];
if (optionalFieldPresent[1])
{
// Deserialize antennaInfo
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 1)
{
bIterator = DeserializeNull (bIterator);
}
else if (sel == 0)
{
std::bitset<1> codebookSubsetRestrictionPresent;
bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,false,bIterator);
int txmode;
bIterator = DeserializeEnum (8,&txmode,bIterator);
physicalConfigDedicated->antennaInfo.transmissionMode = txmode;
if (codebookSubsetRestrictionPresent[0])
{
// Deserialize codebookSubsetRestriction
// ...
}
int txantennaselchosen;
bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator);
if (txantennaselchosen == 0)
{
// Deserialize ue-TransmitAntennaSelection release
bIterator = DeserializeNull (bIterator);
}
else if (txantennaselchosen == 1)
{
// Deserialize ue-TransmitAntennaSelection setup
// ...
}
}
}
if (optionalFieldPresent[0])
{
// Deserialize schedulingRequestConfig
// ...
}
return bIterator;
}
void
RrcAsn1Header::Print (std::ostream &os) const
{
NS_LOG_FUNCTION (this << &os);
NS_FATAL_ERROR ("RrcAsn1Header Print() function must also specify LteRrcSap::RadioResourceConfigDedicated as a second argument");
}
Buffer::Iterator
RrcAsn1Header::DeserializeNonCriticalExtensionConfig (LteRrcSap::NonCriticalExtensionConfiguration *nonCriticalExtension, Buffer::Iterator bIterator)
{
NS_LOG_FUNCTION (this);
std::bitset<2> nonCriticalExtension_v890;
bIterator = DeserializeSequence (&nonCriticalExtension_v890, false,bIterator);
if (nonCriticalExtension_v890[0])
{
// Continue to analyze future Release optional fields
std::bitset<3> nonCriticalExtension_v920;
bIterator = DeserializeSequence (&nonCriticalExtension_v920, false, bIterator);
if (nonCriticalExtension_v920[0])
{
// Continue to deserialize futere Release optional fields
std::bitset<3> nonCriticalExtension_v1020;
bIterator = DeserializeSequence (&nonCriticalExtension_v1020, false, bIterator);
int numElems;
bIterator = DeserializeSequenceOf (&numElems,MAX_OBJECT_ID,1,bIterator);
nonCriticalExtension->sCellsToAddModList.clear ();
// Deserialize SCellToAddMod
for (int i = 0; i < numElems; i++)
{
std::bitset<4> sCellToAddMod_r10;
bIterator = DeserializeSequence (&sCellToAddMod_r10, false, bIterator);
LteRrcSap::SCellToAddMod sctam;
// Deserialize sCellIndex
int n;
bIterator = DeserializeInteger (&n,1,MAX_OBJECT_ID,bIterator);
sctam.sCellIndex = n;
// Deserialize CellIdentification
bIterator = DeserializeCellIdentification (&sctam.cellIdentification, bIterator);
// Deserialize RadioResourceConfigCommonSCell
bIterator = DeserializeRadioResourceConfigCommonSCell (&sctam.radioResourceConfigCommonSCell, bIterator);
if (sCellToAddMod_r10[0])
{
//Deserialize RadioResourceConfigDedicatedSCell
bIterator = DeserializeRadioResourceConfigDedicatedSCell (&sctam.radioResourceConfigDedicateSCell, bIterator);
}
nonCriticalExtension->sCellsToAddModList.insert (nonCriticalExtension->sCellsToAddModList.end (), sctam);
}
}
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeCellIdentification (LteRrcSap::CellIdentification *ci, Buffer::Iterator bIterator)
{
NS_LOG_FUNCTION (this);
std::bitset<2> cellIdentification_r10;
bIterator = DeserializeSequence (&cellIdentification_r10,false,bIterator);
int n1;
bIterator = DeserializeInteger (&n1,1,65536,bIterator);
ci->physCellId = n1;
int n2;
bIterator = DeserializeInteger (&n2,1,65536,bIterator);
ci->dlCarrierFreq = n2;
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigCommonSCell (LteRrcSap::RadioResourceConfigCommonSCell *rrccsc, Buffer::Iterator bIterator)
{
NS_LOG_FUNCTION (this);
std::bitset<2> radioResourceConfigCommonSCell_r10;
bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,bIterator);
rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1];
rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0];
if (rrccsc->haveNonUlConfiguration)
{
std::bitset<5> nonUlConfiguration_r10;
bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator);
int n;
bIterator = DeserializeInteger (&n,6,100,bIterator);
rrccsc->nonUlConfiguration.dlBandwidth = n;
std::bitset<1> antennaInfoCommon_r10;
bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator);
bIterator = DeserializeInteger (&n,0,65536,bIterator);
rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = n;
std::bitset<2> pdschConfigCommon_r10;
bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator);
bIterator = DeserializeInteger (&n,-60,50,bIterator);
rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = n;
bIterator = DeserializeInteger (&n,0,3,bIterator);
rrccsc->nonUlConfiguration.pdschConfigCommon.pb = n;
}
if (rrccsc->haveUlConfiguration)
{
std::bitset<7> UlConfiguration_r10;
bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator);
std::bitset<3> FreqInfo_r10;
bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator);
int n;
bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n;
bIterator = DeserializeInteger (&n,6,100,bIterator);
rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = n;
std::bitset<2> UlPowerControlCommonSCell_r10;
bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bIterator);
bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = n;
std::bitset<1> prachConfigSCell_r10;
bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator);
bIterator = DeserializeInteger (&n,0,256,bIterator);
rrccsc->ulConfiguration.prachConfigSCell.index = n;
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioResourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator)
{
NS_LOG_FUNCTION (this);
std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
bIterator = DeserializeSequence (&RadioResourceConfigDedicatedSCell_r10,false,bIterator);
DeserializePhysicalConfigDedicatedSCell (&rrcdsc->physicalConfigDedicatedSCell, bIterator);
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializePhysicalConfigDedicatedSCell (LteRrcSap::PhysicalConfigDedicatedSCell *pcdsc, Buffer::Iterator bIterator)
{
NS_LOG_FUNCTION (this);
std::bitset<2> pcdscOpt;
bIterator = DeserializeSequence (&pcdscOpt,true,bIterator);
pcdsc->haveNonUlConfiguration = pcdscOpt[1];
pcdsc->haveUlConfiguration = pcdscOpt[0];
if (pcdsc->haveNonUlConfiguration)
{
std::bitset<4> nulOpt;
bIterator = DeserializeSequence (&nulOpt,false,bIterator);
pcdsc->haveAntennaInfoDedicated = nulOpt[3];
pcdsc->havePdschConfigDedicated = nulOpt[0];
if (pcdsc->haveAntennaInfoDedicated)
{
// Deserialize antennaInfo
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 1)
{
bIterator = DeserializeNull (bIterator);
}
else if (sel == 0)
{
std::bitset<1> codebookSubsetRestrictionPresent;
bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,false,bIterator);
int txmode;
bIterator = DeserializeEnum (8,&txmode,bIterator);
pcdsc->antennaInfo.transmissionMode = txmode;
if (codebookSubsetRestrictionPresent[0])
{
// Deserialize codebookSubsetRestriction
// ...
}
int txantennaselchosen;
bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator);
if (txantennaselchosen == 0)
{
// Deserialize ue-TransmitAntennaSelection release
bIterator = DeserializeNull (bIterator);
}
else if (txantennaselchosen == 1)
{
// Deserialize ue-TransmitAntennaSelection setup
// ...
}
}
}
if (pcdsc->havePdschConfigDedicated)
{
// Deserialize pdsch-ConfigDedicated
std::bitset<0> bitset0;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
int slct;
// Deserialize p-a
bIterator = DeserializeEnum (8,&slct,bIterator);
pcdsc->pdschConfigDedicated.pa = slct;
bIterator = DeserializeNull (bIterator);
}
}
if (pcdsc->haveUlConfiguration)
{
std::bitset<7> ulOpt;
bIterator = DeserializeSequence (&ulOpt,false,bIterator);
pcdsc->haveAntennaInfoUlDedicated = ulOpt[6];
pcdsc->haveSoundingRsUlConfigDedicated = ulOpt[2];
if (pcdsc->haveAntennaInfoUlDedicated)
{
// Deserialize antennaInfo
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 1)
{
bIterator = DeserializeNull (bIterator);
}
else if (sel == 0)
{
std::bitset<1> codebookSubsetRestrictionPresent;
bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,false,bIterator);
int txmode;
bIterator = DeserializeEnum (8,&txmode,bIterator);
pcdsc->antennaInfo.transmissionMode = txmode;
if (codebookSubsetRestrictionPresent[0])
{
// Deserialize codebookSubsetRestriction
// ...
}
int txantennaselchosen;
bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator);
if (txantennaselchosen == 0)
{
// Deserialize ue-TransmitAntennaSelection release
bIterator = DeserializeNull (bIterator);
}
else if (txantennaselchosen == 1)
{
// Deserialize ue-TransmitAntennaSelection setup
// ...
}
}
}
if (pcdsc->haveSoundingRsUlConfigDedicated)
{
// Deserialize soundingRS-UL-ConfigDedicated
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 0)
{
pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::RESET;
bIterator = DeserializeNull (bIterator);
}
else if (sel == 1)
{
pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::SETUP;
std::bitset<0> bitset0;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
int slct;
// Deserialize srs-Bandwidth
bIterator = DeserializeEnum (4,&slct,bIterator);
pcdsc->soundingRsUlConfigDedicated.srsBandwidth = slct;
// Deserialize srs-HoppingBandwidth
bIterator = DeserializeEnum (4,&slct,bIterator);
// Deserialize freqDomainPosition
bIterator = DeserializeInteger (&slct,0,23,bIterator);
// Deserialize duration
bool duration;
bIterator = DeserializeBoolean (&duration,bIterator);
// Deserialize srs-ConfigIndex
bIterator = DeserializeInteger (&slct,0,1023,bIterator);
pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = slct;
// Deserialize transmissionComb
bIterator = DeserializeInteger (&slct,0,1,bIterator);
// Deserialize cyclicShift
bIterator = DeserializeEnum (8,&slct,bIterator);
}
}
}
return bIterator;
}
void
RrcAsn1Header::Print (std::ostream &os, LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
{
os << " srbToAddModList: " << std::endl;
std::list<LteRrcSap::SrbToAddMod>::iterator it = radioResourceConfigDedicated.srbToAddModList.begin ();
for (; it != radioResourceConfigDedicated.srbToAddModList.end (); it++)
{
os << " srbIdentity: " << (int)it->srbIdentity << std::endl;
os << " logicalChannelConfig: " << std::endl;
os << " priority: " << (int)it->logicalChannelConfig.priority << std::endl;
os << " prioritizedBitRateKbps: " << (int)it->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
os << " bucketSizeDurationMs: " << (int)it->logicalChannelConfig.bucketSizeDurationMs << std::endl;
os << " logicalChannelGroup: " << (int)it->logicalChannelConfig.logicalChannelGroup << std::endl;
}
os << std::endl;
os << " drbToAddModList: " << std::endl;
std::list<LteRrcSap::DrbToAddMod>::iterator it2 = radioResourceConfigDedicated.drbToAddModList.begin ();
for (; it2 != radioResourceConfigDedicated.drbToAddModList.end (); it2++)
{
os << " epsBearerIdentity: " << (int)it2->epsBearerIdentity << std::endl;
os << " drbIdentity: " << (int)it2->drbIdentity << std::endl;
os << " rlcConfig: " << it2->rlcConfig.choice << std::endl;
os << " logicalChannelIdentity: " << (int)it2->logicalChannelIdentity << std::endl;
os << " logicalChannelConfig: " << std::endl;
os << " priority: " << (int)it2->logicalChannelConfig.priority << std::endl;
os << " prioritizedBitRateKbps: " << (int)it2->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
os << " bucketSizeDurationMs: " << (int)it2->logicalChannelConfig.bucketSizeDurationMs << std::endl;
os << " logicalChannelGroup: " << (int)it2->logicalChannelConfig.logicalChannelGroup << std::endl;
}
os << std::endl;
os << " drbToReleaseList: ";
std::list<uint8_t>::iterator it3 = radioResourceConfigDedicated.drbToReleaseList.begin ();
for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end (); it3++)
{
os << (int)*it3 << ", ";
}
os << std::endl;
os << " havePhysicalConfigDedicated: " << radioResourceConfigDedicated.havePhysicalConfigDedicated << std::endl;
if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
{
os << " physicalConfigDedicated: " << std::endl;
os << " haveSoundingRsUlConfigDedicated: " << radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated << std::endl;
if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
{
os << " soundingRsUlConfigDedicated: " << std::endl;
os << " type: " << radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.type << std::endl;
os << " srsBandwidth: " << (int)radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth << std::endl;
os << " srsConfigIndex: " << (int)radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex << std::endl;
}
os << " haveAntennaInfoDedicated: " << radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated << std::endl;
if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated)
{
os << " antennaInfo Tx mode: " << (int)radioResourceConfigDedicated.physicalConfigDedicated.antennaInfo.transmissionMode << std::endl;
}
}
}
Buffer::Iterator
RrcAsn1Header::DeserializeSystemInformationBlockType1 (LteRrcSap::SystemInformationBlockType1 *systemInformationBlockType1, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
std::bitset<3> sysInfoBlkT1Opts;
bIterator = DeserializeSequence (&sysInfoBlkT1Opts,false,bIterator);
// Deserialize cellAccessRelatedInfo
std::bitset<1> cellAccessRelatedInfoOpts;
bIterator = DeserializeSequence (&cellAccessRelatedInfoOpts,false,bIterator);
// Deserialize plmn-IdentityList
int numPlmnIdentityInfoElements;
bIterator = DeserializeSequenceOf (&numPlmnIdentityInfoElements,6,1,bIterator);
for (int i = 0; i < numPlmnIdentityInfoElements; i++)
{
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// plmn-Identity
bIterator = DeserializePlmnIdentity (&systemInformationBlockType1->cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity,bIterator);
}
// Deserialize trackingAreaCode
std::bitset<16> trackingAreaCode;
bIterator = DeserializeBitstring (&trackingAreaCode,bIterator);
// Deserialize cellIdentity
std::bitset<28> cellIdentity;
bIterator = DeserializeBitstring (&cellIdentity,bIterator);
systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdentity.to_ulong ();
// Deserialize cellBarred
bIterator = DeserializeEnum (2,&n,bIterator);
// Deserialize intraFreqReselection
bIterator = DeserializeEnum (2,&n,bIterator);
// Deserialize csg-Indication
bIterator = DeserializeBoolean (&systemInformationBlockType1->cellAccessRelatedInfo.csgIndication,bIterator);
if (cellAccessRelatedInfoOpts[0])
{
// Deserialize csg-Identity
std::bitset<27> csgIdentity;
bIterator = DeserializeBitstring (&csgIdentity,bIterator);
systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIdentity.to_ulong ();
}
// Deserialize cellSelectionInfo
std::bitset<1> qRxLevMinOffsetPresent;
bIterator = DeserializeSequence (&qRxLevMinOffsetPresent,false,bIterator);
bIterator = DeserializeInteger (&n,-70,-22,bIterator); //q-RxLevMin
if (qRxLevMinOffsetPresent[0])
{
// Deserialize qRxLevMinOffset
// ...
}
if (sysInfoBlkT1Opts[2])
{
// Deserialize p-Max
// ...
}
// freqBandIndicator
bIterator = DeserializeInteger (&n,1,64,bIterator);
// schedulingInfoList
int numSchedulingInfo;
bIterator = DeserializeSequenceOf (&numSchedulingInfo,MAX_SI_MESSAGE,1,bIterator);
for (int i = 0; i < numSchedulingInfo; i++)
{
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (7,&n,bIterator); // si-Periodicity
int numSibType;
bIterator = DeserializeSequenceOf (&numSibType,MAX_SIB - 1,0, bIterator); // sib-MappingInfo
for (int j = 0; j < numSibType; j++)
{
bIterator = DeserializeEnum (16,&n,bIterator); // SIB-Type
}
}
if (sysInfoBlkT1Opts[1])
{
// tdd-Config
// ...
}
// si-WindowLength
bIterator = DeserializeEnum (7,&n,bIterator);
// systemInfoValueTag
bIterator = DeserializeInteger (&n,0,31,bIterator);
if (sysInfoBlkT1Opts[0])
{
// Deserialize nonCriticalExtension
// ...
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeSystemInformationBlockType2 (LteRrcSap::SystemInformationBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
std::bitset<2> sysInfoBlkT2Opts;
bIterator = DeserializeSequence (&sysInfoBlkT2Opts,true,bIterator);
if (sysInfoBlkT2Opts[1])
{
// Deserialize ac-BarringInfo
// ...
}
// Deserialize radioResourceConfigCommon
bIterator = DeserializeRadioResourceConfigCommonSib (&systemInformationBlockType2->radioResourceConfigCommon, bIterator);
// Deserialize ue-TimersAndConstants
bIterator = DeserializeSequence (&bitset0,true,bIterator);
bIterator = DeserializeEnum (8,&n,bIterator); // t300
bIterator = DeserializeEnum (8,&n,bIterator); // t301
bIterator = DeserializeEnum (7,&n,bIterator); // t310
bIterator = DeserializeEnum (8,&n,bIterator); // n310
bIterator = DeserializeEnum (7,&n,bIterator); // t311
bIterator = DeserializeEnum (8,&n,bIterator); // n311
// Deserialize freqInfo
std::bitset<2> freqInfoOpts;
bIterator = DeserializeSequence (&freqInfoOpts,false,bIterator);
if (freqInfoOpts[1])
{
// Deserialize ul-CarrierFreq
bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator);
systemInformationBlockType2->freqInfo.ulCarrierFreq = n;
}
if (freqInfoOpts[0])
{
// Deserialize ul-Bandwidth
bIterator = DeserializeEnum (6, &n, bIterator);
switch (n)
{
case 0:
systemInformationBlockType2->freqInfo.ulBandwidth = 6;
break;
case 1:
systemInformationBlockType2->freqInfo.ulBandwidth = 15;
break;
case 2:
systemInformationBlockType2->freqInfo.ulBandwidth = 25;
break;
case 3:
systemInformationBlockType2->freqInfo.ulBandwidth = 50;
break;
case 4:
systemInformationBlockType2->freqInfo.ulBandwidth = 75;
break;
case 5:
systemInformationBlockType2->freqInfo.ulBandwidth = 100;
break;
default:
systemInformationBlockType2->freqInfo.ulBandwidth = 6;
}
}
// additionalSpectrumEmission
bIterator = DeserializeInteger (&n,1,32,bIterator);
if (sysInfoBlkT2Opts[0])
{
// Deserialize mbsfn-SubframeConfigList
// ...
}
// Deserialize timeAlignmentTimerCommon
bIterator = DeserializeEnum (8,&n,bIterator);
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfigCommon * radioResourceConfigCommon, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
std::bitset<9> rrCfgCommOptions;
bIterator = DeserializeSequence (&rrCfgCommOptions,true,bIterator);
// rach-ConfigCommon
if (rrCfgCommOptions[8])
{
bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommon->rachConfigCommon, bIterator);
}
// prach-Config
std::bitset<1> prachConfigInfoPresent;
bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator);
// prach-Config -> rootSequenceIndex
bIterator = DeserializeInteger (&n,0,1023,bIterator);
// prach-Config -> prach-ConfigInfo
if (prachConfigInfoPresent[0])
{
// ...
}
// pdsch-ConfigCommon
if (rrCfgCommOptions[7])
{
// ...
}
// pusch-ConfigCommon
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
bIterator = DeserializeInteger (&n,1,4,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
bIterator = DeserializeEnum (2,&n,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
bIterator = DeserializeInteger (&n,0,98,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
bool enable64QAM;
bIterator = DeserializeBoolean (&enable64QAM,bIterator);
// ul-ReferenceSignalsPUSCH
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// groupHoppingEnabled
bool dummyBool;
bIterator = DeserializeBoolean (&dummyBool,bIterator);
// groupAssignmentPUSCH
bIterator = DeserializeInteger (&n,0,29,bIterator);
// sequenceHoppingEnabled
bIterator = DeserializeBoolean (&dummyBool,bIterator);
// cyclicShift
bIterator = DeserializeInteger (&n,0,7,bIterator);
// phich-Config
if (rrCfgCommOptions[6])
{
// ...
}
// pucch-ConfigCommon
if (rrCfgCommOptions[5])
{
// ...
}
// soundingRS-UL-ConfigCommon
if (rrCfgCommOptions[4])
{
// ...
}
// uplinkPowerControlCommon
if (rrCfgCommOptions[3])
{
// ...
}
// antennaInfoCommon
if (rrCfgCommOptions[2])
{
// ...
}
// p-Max
if (rrCfgCommOptions[1])
{
// ...
}
// tdd-Config
if (rrCfgCommOptions[0])
{
// ...
}
// ul-CyclicPrefixLength
bIterator = DeserializeEnum (2,&n,bIterator);
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rachConfigCommon, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,true,bIterator);
// preambleInfo
std::bitset<1> preamblesGroupAConfigPresent;
bIterator = DeserializeSequence (&preamblesGroupAConfigPresent,false,bIterator);
// numberOfRA-Preambles
bIterator = DeserializeEnum (16,&n,bIterator);
switch (n)
{
case 0:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
break;
case 1:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 8;
break;
case 2:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 12;
break;
case 3:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 16;
break;
case 4:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 20;
break;
case 5:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 24;
break;
case 6:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 28;
break;
case 7:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 32;
break;
case 8:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 36;
break;
case 9:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 40;
break;
case 10:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 44;
break;
case 11:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 48;
break;
case 12:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 52;
break;
case 13:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 56;
break;
case 14:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 60;
break;
case 15:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 64;
break;
default:
rachConfigCommon->preambleInfo.numberOfRaPreambles = 0;
}
rachConfigCommon->preambleInfo.numberOfRaPreambles = n;
if (preamblesGroupAConfigPresent[0])
{
// Deserialize preamblesGroupAConfig
// ...
}
// powerRampingParameters
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep
bIterator = DeserializeEnum (16,&n,bIterator); // preambleInitialReceivedTargetPower
// ra-SupervisionInfo
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (11,&n,bIterator); // preambleTransMax
switch (n)
{
case 0:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 3;
break;
case 1:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 4;
break;
case 2:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 5;
break;
case 3:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 6;
break;
case 4:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 7;
break;
case 5:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 8;
break;
case 6:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 10;
break;
case 7:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 20;
break;
case 8:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 50;
break;
case 9:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 100;
break;
case 10:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 200;
break;
default:
rachConfigCommon->raSupervisionInfo.preambleTransMax = 0;
}
// ra-ResponseWindowSize
bIterator = DeserializeEnum (8,&n,bIterator);
switch (n)
{
case 0:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2;
break;
case 1:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3;
break;
case 2:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4;
break;
case 3:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5;
break;
case 4:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6;
break;
case 5:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7;
break;
case 6:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8;
break;
case 7:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10;
break;
default:
rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0;
}
bIterator = DeserializeEnum (8,&n,bIterator); // mac-ContentionResolutionTimer
bIterator = DeserializeInteger (&n,1,8,bIterator); //maxHARQ-Msg3Tx
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceConfigCommonSib * radioResourceConfigCommonSib, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,true,bIterator);
// rach-ConfigCommon
bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommonSib->rachConfigCommon, bIterator);
// bcch-Config
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (4,&n,bIterator); // modificationPeriodCoeff
// pcch-Config
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (4,&n,bIterator); // defaultPagingCycle
bIterator = DeserializeEnum (8,&n,bIterator); // nB
// prach-Config
std::bitset<1> prachConfigInfoPresent;
bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator);
// prach-Config -> rootSequenceIndex
bIterator = DeserializeInteger (&n,0,1023,bIterator);
// prach-Config -> prach-ConfigInfo
if (prachConfigInfoPresent[0])
{
// ...
}
// pdsch-ConfigCommon
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeInteger (&n,-60,50,bIterator); // referenceSignalPower
bIterator = DeserializeInteger (&n,0,3,bIterator); // p-b
// pusch-ConfigCommon
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
bIterator = DeserializeInteger (&n,1,4,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
bIterator = DeserializeEnum (2,&n,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
bIterator = DeserializeInteger (&n,0,98,bIterator);
// pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
bool dummyBoolean;
bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
// ul-ReferenceSignalsPUSCH
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// groupHoppingEnabled
bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
// groupAssignmentPUSCH
bIterator = DeserializeInteger (&n,0,29,bIterator);
// sequenceHoppingEnabled
bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
// cyclicShift
bIterator = DeserializeInteger (&n,0,7,bIterator);
// pucch-ConfigCommon
bIterator = DeserializeEnum (3,&n,bIterator); // deltaPUCCH-Shift
bIterator = DeserializeInteger (&n,0,98,bIterator); // nRB-CQI
bIterator = DeserializeInteger (&n,0,7,bIterator); // nCS-AN
bIterator = DeserializeInteger (&n,0,2047,bIterator); // n1PUCCH-AN
// soundingRS-UL-ConfigCommon
int choice;
bIterator = DeserializeChoice (2,false,&choice,bIterator);
if (choice == 0)
{
bIterator = DeserializeNull (bIterator); // release
}
if (choice == 1)
{
// setup
// ...
}
// uplinkPowerControlCommon
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeInteger (&n,-126,24,bIterator); // p0-NominalPUSCH
bIterator = DeserializeEnum (8,&n,bIterator); // alpha
bIterator = DeserializeInteger (&n,-127,-96,bIterator); // p0-NominalPUCCH
//deltaFList-PUCCH
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1
bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1b
bIterator = DeserializeEnum (4,&n,bIterator); // deltaF-PUCCH-Format2
bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2a
bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2b
bIterator = DeserializeInteger (&n,-1,6,bIterator); // deltaPreambleMsg3
// ul-CyclicPrefixLength
bIterator = DeserializeEnum (2,&n,bIterator);
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator)
{
int n;
std::bitset<0> b0;
std::bitset<4> measResultOptionalPresent;
// bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIterator);
bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator);
// Deserialize measId
bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
measResults->measId = n;
// Deserialize measResultServCell
bIterator = DeserializeSequence (&b0,false,bIterator);
// Deserialize rsrpResult
bIterator = DeserializeInteger (&n, 0, 97, bIterator);
measResults->rsrpResult = n;
// Deserialize rsrqResult
bIterator = DeserializeInteger (&n, 0, 34, bIterator);
measResults->rsrqResult = n;
measResults->haveMeasResultNeighCells = measResultOptionalPresent[0];
measResults->haveScellsMeas = measResultOptionalPresent[3];
if ( measResults->haveMeasResultNeighCells)
{
int measResultNeighCellsChoice;
// Deserialize measResultNeighCells
bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterator);
if (measResultNeighCellsChoice == 0)
{
// Deserialize measResultListEUTRA
int numElems;
bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterator);
for (int i = 0; i < numElems; i++)
{
LteRrcSap::MeasResultEutra measResultEutra;
std::bitset<1> isCgiInfoPresent;
bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator);
// PhysCellId
bIterator = DeserializeInteger (&n,0,503,bIterator);
measResultEutra.physCellId = n;
measResultEutra.haveCgiInfo = isCgiInfoPresent[0];
if (isCgiInfoPresent[0])
{
std::bitset<1> havePlmnIdentityList;
bIterator = DeserializeSequence (&havePlmnIdentityList,false,bIterator);
// Deserialize cellGlobalId
bIterator = DeserializeSequence (&b0,false,bIterator);
// Deserialize plmn-Identity
bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.plmnIdentity,bIterator);
// Deserialize CellIdentity
std::bitset<28> cellId;
bIterator = DeserializeBitstring (&cellId,bIterator);
measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong ();
// Deserialize trackingAreaCode
std::bitset<16> trArCo;
bIterator = DeserializeBitstring (&trArCo,bIterator);
measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong ();
// Deserialize plmn-IdentityList
if (havePlmnIdentityList[0])
{
int numPlmnElems;
bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bIterator);
for ( int j = 0; j < numPlmnElems; j++)
{
uint32_t plmnId;
bIterator = DeserializePlmnIdentity (&plmnId,bIterator);
measResultEutra.cgiInfo.plmnIdentityList.push_back (plmnId);
}
}
}
// Deserialize measResult
std::bitset<2> measResultOpts;
bIterator = DeserializeSequence (&measResultOpts, true, bIterator);
measResultEutra.haveRsrpResult = measResultOpts[1];
if (measResultOpts[1])
{
// Deserialize rsrpResult
bIterator = DeserializeInteger (&n,0,97,bIterator);
measResultEutra.rsrpResult = n;
}
measResultEutra.haveRsrqResult = measResultOpts[0];
if (measResultOpts[0])
{
// Deserialize rsrqResult
bIterator = DeserializeInteger (&n,0,34,bIterator);
measResultEutra.rsrqResult = n;
}
measResults->measResultListEutra.push_back (measResultEutra);
}
}
if (measResultNeighCellsChoice == 1)
{
// Deserialize measResultListUTRA
// ...
}
if (measResultNeighCellsChoice == 2)
{
// Deserialize measResultListGERAN
// ...
}
if (measResultNeighCellsChoice == 3)
{
// Deserialize measResultsCDMA2000
// ...
}
}
if (measResults->haveScellsMeas)
{
int numElems;
bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterator);
for (int i = 0; i < numElems; i++)
{
LteRrcSap::MeasResultScell measResultScell;
int measScellId;
// Deserialize measId
bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIterator);
measResultScell.servFreqId = measScellId;
std::bitset<2> measResultScellPresent;
bIterator = DeserializeSequence (&measResultScellPresent,true,bIterator);
measResults->measScellResultList.haveMeasurementResultsServingSCells = measResultScellPresent[0];
measResults->measScellResultList.haveMeasurementResultsNeighCell = measResultScellPresent[1];
if (measResults->measScellResultList.haveMeasurementResultsServingSCells)
{
// Deserialize measResult
std::bitset<2> measResultOpts;
bIterator = DeserializeSequence (&measResultOpts, true, bIterator);
measResultScell.haveRsrpResult = measResultOpts[1];
if (measResultOpts[1])
{
// Deserialize rsrpResult
bIterator = DeserializeInteger (&n,0,97,bIterator);
measResultScell.rsrpResult = n;
}
measResultScell.haveRsrqResult = measResultOpts[0];
if (measResultOpts[0])
{
// Deserialize rsrqResult
bIterator = DeserializeInteger (&n,0,34,bIterator);
measResultScell.rsrqResult = n;
}
}
if (measResults->measScellResultList.haveMeasurementResultsNeighCell)
{
// Deserialize measResultBestNeighCell
}
measResults->measScellResultList.measResultScell.push_back (measResultScell);
}
}
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIterator)
{
int n;
std::bitset<1> isMccPresent;
bIterator = DeserializeSequence (&isMccPresent,false,bIterator);
if (isMccPresent[0])
{
// Deserialize mcc
// ...
}
// Deserialize mnc
int mncDigits;
int mnc = 0;
bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator);
for (int j = mncDigits - 1; j >= 0; j--)
{
bIterator = DeserializeInteger (&n,0,9,bIterator);
mnc += n * pow (10,j);
}
*plmnId = mnc;
// cellReservedForOperatorUse
bIterator = DeserializeEnum (2,&n,bIterator);
return bIterator;
}
Buffer::Iterator
RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
std::bitset<2> bitset2;
std::bitset<11> bitset11;
int n;
// measConfig
bIterator = DeserializeSequence (&bitset11,true,bIterator);
if (bitset11[10])
{
// measObjectToRemoveList
int measObjectToRemoveListElems;
bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator);
for (int i = 0; i < measObjectToRemoveListElems; i++)
{
bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
measConfig->measObjectToRemoveList.push_back (n);
}
}
if (bitset11[9])
{
// measObjectToAddModList
int measObjectToAddModListElems;
bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator);
for (int i = 0; i < measObjectToAddModListElems; i++)
{
LteRrcSap::MeasObjectToAddMod elem;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
elem.measObjectId = n;
int measObjectChoice;
bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator);
switch (measObjectChoice)
{
case 1:
// Deserialize measObjectUTRA
// ...
break;
case 2:
// Deserialize measObjectGERAN
// ...
break;
case 3:
// Deserialize measObjectCDMA2000
// ...
break;
case 0:
default:
// Deserialize measObjectEUTRA
std::bitset<5> measObjectEutraOpts;
bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator);
// carrierFreq
bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator);
elem.measObjectEutra.carrierFreq = n;
// allowedMeasBandwidth
bIterator = DeserializeEnum (6, &n, bIterator);
switch (n)
{
case 0:
elem.measObjectEutra.allowedMeasBandwidth = 6;
break;
case 1:
elem.measObjectEutra.allowedMeasBandwidth = 15;
break;
case 2:
elem.measObjectEutra.allowedMeasBandwidth = 25;
break;
case 3:
elem.measObjectEutra.allowedMeasBandwidth = 50;
break;
case 4:
elem.measObjectEutra.allowedMeasBandwidth = 75;
break;
case 5:
default:
elem.measObjectEutra.allowedMeasBandwidth = 100;
break;
}
// presenceAntennaPort1
bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAntennaPort1, bIterator);
// neighCellConfig
bIterator = DeserializeBitstring (&bitset2, bIterator);
elem.measObjectEutra.neighCellConfig = bitset2.to_ulong ();
// offsetFreq
bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetFreq, bIterator);
if (measObjectEutraOpts[4])
{
// cellsToRemoveList
int numElems;
bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
for (int i = 0; i < numElems; i++)
{
bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
elem.measObjectEutra.cellsToRemoveList.push_back (n);
}
}
if (measObjectEutraOpts[3])
{
// cellsToAddModList
int numElems;
bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
for (int i = 0; i < numElems; i++)
{
LteRrcSap::CellsToAddMod cellsToAddMod;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
// cellIndex
bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
cellsToAddMod.cellIndex = n;
// PhysCellId
bIterator = DeserializeInteger (&n, 0, 503, bIterator);
cellsToAddMod.physCellId = n;
// cellIndividualOffset
bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellIndividualOffset, bIterator);
elem.measObjectEutra.cellsToAddModList.push_back (cellsToAddMod);
}
}
if (measObjectEutraOpts[2])
{
// blackCellsToRemoveList
int numElems;
bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
for (int i = 0; i < numElems; i++)
{
bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
elem.measObjectEutra.blackCellsToRemoveList.push_back (n);
}
}
if (measObjectEutraOpts[1])
{
// blackCellsToAddModList
int numElems;
bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
for (int i = 0; i < numElems; i++)
{
LteRrcSap::BlackCellsToAddMod blackCellsToAddMod;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
blackCellsToAddMod.cellIndex = n;
// PhysCellIdRange
std::bitset<1> isRangePresent;
bIterator = DeserializeSequence (&isRangePresent, false, bIterator);
// start
bIterator = DeserializeInteger (&n, 0, 503, bIterator);
blackCellsToAddMod.physCellIdRange.start = n;
blackCellsToAddMod.physCellIdRange.haveRange = isRangePresent[0];
// initialize range to silence compiler warning
blackCellsToAddMod.physCellIdRange.range = 0;
if (blackCellsToAddMod.physCellIdRange.haveRange)
{
// range
bIterator = DeserializeEnum (16, &n, bIterator);
switch (n)
{
case 0:
blackCellsToAddMod.physCellIdRange.range = 4;
break;
case 1:
blackCellsToAddMod.physCellIdRange.range = 8;
break;
case 2:
blackCellsToAddMod.physCellIdRange.range = 12;
break;
case 3:
blackCellsToAddMod.physCellIdRange.range = 16;
break;
case 4:
blackCellsToAddMod.physCellIdRange.range = 24;
break;
case 5:
blackCellsToAddMod.physCellIdRange.range = 32;
break;
case 6:
blackCellsToAddMod.physCellIdRange.range = 48;
break;
case 7:
blackCellsToAddMod.physCellIdRange.range = 64;
break;
case 8:
blackCellsToAddMod.physCellIdRange.range = 84;
break;
case 9:
blackCellsToAddMod.physCellIdRange.range = 96;
break;
case 10:
blackCellsToAddMod.physCellIdRange.range = 128;
break;
case 11:
blackCellsToAddMod.physCellIdRange.range = 168;
break;
case 12:
blackCellsToAddMod.physCellIdRange.range = 252;
break;
case 13:
blackCellsToAddMod.physCellIdRange.range = 504;
break;
default:
blackCellsToAddMod.physCellIdRange.range = 0;
}
}
elem.measObjectEutra.blackCellsToAddModList.push_back (blackCellsToAddMod);
}
}
elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0];
if (measObjectEutraOpts[0])
{
// cellForWhichToReportCGI
bIterator = DeserializeInteger (&n, 0, 503, bIterator);
elem.measObjectEutra.cellForWhichToReportCGI = n;
}
}
measConfig->measObjectToAddModList.push_back (elem);
}
}
if (bitset11[8])
{
// reportConfigToRemoveList
int reportConfigToRemoveListElems;
bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
for (int i = 0; i < reportConfigToRemoveListElems; i++)
{
bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
measConfig->reportConfigToRemoveList.push_back (n);
}
}
if (bitset11[7])
{
// reportConfigToAddModList
int reportConfigToAddModListElems;
bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
for (int i = 0; i < reportConfigToAddModListElems; i++)
{
LteRrcSap::ReportConfigToAddMod elem;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
elem.reportConfigId = n;
// Deserialize reportConfig
int reportConfigChoice;
bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator);
if (reportConfigChoice == 0)
{
// reportConfigEUTRA
bIterator = DeserializeSequence (&bitset0, true, bIterator);
// triggerType
int triggerTypeChoice;
bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator);
if (triggerTypeChoice == 0)
{
// event
elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
// eventId
int eventIdChoice;
bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator);
switch (eventIdChoice)
{
case 0:
elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
break;
case 1:
elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
break;
case 2:
elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n, -30, 30, bIterator);
elem.reportConfigEutra.a3Offset = n;
bIterator = DeserializeBoolean (&elem.reportConfigEutra.reportOnLeave, bIterator);
break;
case 3:
elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
break;
case 4:
default:
elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold2, bIterator);
}
bIterator = DeserializeInteger (&n, 0, 30, bIterator);
elem.reportConfigEutra.hysteresis = n;
bIterator = DeserializeEnum (16, &n, bIterator);
switch (n)
{
case 0:
elem.reportConfigEutra.timeToTrigger = 0;
break;
case 1:
elem.reportConfigEutra.timeToTrigger = 40;
break;
case 2:
elem.reportConfigEutra.timeToTrigger = 64;
break;
case 3:
elem.reportConfigEutra.timeToTrigger = 80;
break;
case 4:
elem.reportConfigEutra.timeToTrigger = 100;
break;
case 5:
elem.reportConfigEutra.timeToTrigger = 128;
break;
case 6:
elem.reportConfigEutra.timeToTrigger = 160;
break;
case 7:
elem.reportConfigEutra.timeToTrigger = 256;
break;
case 8:
elem.reportConfigEutra.timeToTrigger = 320;
break;
case 9:
elem.reportConfigEutra.timeToTrigger = 480;
break;
case 10:
elem.reportConfigEutra.timeToTrigger = 512;
break;
case 11:
elem.reportConfigEutra.timeToTrigger = 640;
break;
case 12:
elem.reportConfigEutra.timeToTrigger = 1024;
break;
case 13:
elem.reportConfigEutra.timeToTrigger = 1280;
break;
case 14:
elem.reportConfigEutra.timeToTrigger = 2560;
break;
case 15:
default:
elem.reportConfigEutra.timeToTrigger = 5120;
break;
}
}
if (triggerTypeChoice == 1)
{
// periodical
elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::PERIODICAL;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeEnum (2, &n, bIterator);
if (n == 0)
{
elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::REPORT_STRONGEST_CELLS;
}
else
{
elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::REPORT_CGI;
}
}
// triggerQuantity
bIterator = DeserializeEnum (2, &n, bIterator);
if (n == 0)
{
elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
}
else
{
elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRQ;
}
// reportQuantity
bIterator = DeserializeEnum (2, &n, bIterator);
if (n == 0)
{
elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::SAME_AS_TRIGGER_QUANTITY;
}
else
{
elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::BOTH;
}
// maxReportCells
bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator);
elem.reportConfigEutra.maxReportCells = n;
// reportInterval
bIterator = DeserializeEnum (16, &n, bIterator);
switch (n)
{
case 0:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS120;
break;
case 1:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS240;
break;
case 2:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS480;
break;
case 3:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS640;
break;
case 4:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS1024;
break;
case 5:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS2048;
break;
case 6:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS5120;
break;
case 7:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MS10240;
break;
case 8:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MIN1;
break;
case 9:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MIN6;
break;
case 10:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MIN12;
break;
case 11:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MIN30;
break;
case 12:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::MIN60;
break;
case 13:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::SPARE3;
break;
case 14:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::SPARE2;
break;
case 15:
default:
elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::SPARE1;
}
// reportAmount
bIterator = DeserializeEnum (8, &n, bIterator);
switch (n)
{
case 0:
elem.reportConfigEutra.reportAmount = 1;
break;
case 1:
elem.reportConfigEutra.reportAmount = 2;
break;
case 2:
elem.reportConfigEutra.reportAmount = 4;
break;
case 3:
elem.reportConfigEutra.reportAmount = 8;
break;
case 4:
elem.reportConfigEutra.reportAmount = 16;
break;
case 5:
elem.reportConfigEutra.reportAmount = 32;
break;
case 6:
elem.reportConfigEutra.reportAmount = 64;
break;
default:
elem.reportConfigEutra.reportAmount = 0;
}
}
if (reportConfigChoice == 1)
{
// ReportConfigInterRAT
// ...
}
measConfig->reportConfigToAddModList.push_back (elem);
}
}
if (bitset11[6])
{
// measIdToRemoveList
int measIdToRemoveListElems;
bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator);
for (int i = 0; i < measIdToRemoveListElems; i++)
{
bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
measConfig->measIdToRemoveList.push_back (n);
}
}
if (bitset11[5])
{
// measIdToAddModList
int measIdToAddModListElems;
bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator);
for (int i = 0; i < measIdToAddModListElems; i++)
{
LteRrcSap::MeasIdToAddMod elem;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
elem.measId = n;
bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
elem.measObjectId = n;
bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
elem.reportConfigId = n;
measConfig->measIdToAddModList.push_back (elem);
}
}
measConfig->haveQuantityConfig = bitset11[4];
if (measConfig->haveQuantityConfig)
{
// quantityConfig
std::bitset<4> quantityConfigOpts;
bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator);
if (quantityConfigOpts[3])
{
// quantityConfigEUTRA
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (16, &n, bIterator);
switch (n)
{
case 0:
measConfig->quantityConfig.filterCoefficientRSRP = 0;
break;
case 1:
measConfig->quantityConfig.filterCoefficientRSRP = 1;
break;
case 2:
measConfig->quantityConfig.filterCoefficientRSRP = 2;
break;
case 3:
measConfig->quantityConfig.filterCoefficientRSRP = 3;
break;
case 4:
measConfig->quantityConfig.filterCoefficientRSRP = 4;
break;
case 5:
measConfig->quantityConfig.filterCoefficientRSRP = 5;
break;
case 6:
measConfig->quantityConfig.filterCoefficientRSRP = 6;
break;
case 7:
measConfig->quantityConfig.filterCoefficientRSRP = 7;
break;
case 8:
measConfig->quantityConfig.filterCoefficientRSRP = 8;
break;
case 9:
measConfig->quantityConfig.filterCoefficientRSRP = 9;
break;
case 10:
measConfig->quantityConfig.filterCoefficientRSRP = 11;
break;
case 11:
measConfig->quantityConfig.filterCoefficientRSRP = 13;
break;
case 12:
measConfig->quantityConfig.filterCoefficientRSRP = 15;
break;
case 13:
measConfig->quantityConfig.filterCoefficientRSRP = 17;
break;
case 14:
measConfig->quantityConfig.filterCoefficientRSRP = 19;
break;
case 15:
measConfig->quantityConfig.filterCoefficientRSRP = 0;
break;
default:
measConfig->quantityConfig.filterCoefficientRSRP = 4;
}
bIterator = DeserializeEnum (16, &n, bIterator);
switch (n)
{
case 0:
measConfig->quantityConfig.filterCoefficientRSRQ = 0;
break;
case 1:
measConfig->quantityConfig.filterCoefficientRSRQ = 1;
break;
case 2:
measConfig->quantityConfig.filterCoefficientRSRQ = 2;
break;
case 3:
measConfig->quantityConfig.filterCoefficientRSRQ = 3;
break;
case 4:
measConfig->quantityConfig.filterCoefficientRSRQ = 4;
break;
case 5:
measConfig->quantityConfig.filterCoefficientRSRQ = 5;
break;
case 6:
measConfig->quantityConfig.filterCoefficientRSRQ = 6;
break;
case 7:
measConfig->quantityConfig.filterCoefficientRSRQ = 7;
break;
case 8:
measConfig->quantityConfig.filterCoefficientRSRQ = 8;
break;
case 9:
measConfig->quantityConfig.filterCoefficientRSRQ = 9;
break;
case 10:
measConfig->quantityConfig.filterCoefficientRSRQ = 11;
break;
case 11:
measConfig->quantityConfig.filterCoefficientRSRQ = 13;
break;
case 12:
measConfig->quantityConfig.filterCoefficientRSRQ = 15;
break;
case 13:
measConfig->quantityConfig.filterCoefficientRSRQ = 17;
break;
case 14:
measConfig->quantityConfig.filterCoefficientRSRQ = 19;
break;
case 15:
measConfig->quantityConfig.filterCoefficientRSRQ = 0;
break;
default:
measConfig->quantityConfig.filterCoefficientRSRQ = 4;
}
}
if (quantityConfigOpts[2])
{
// quantityConfigUTRA
// ...
}
if (quantityConfigOpts[1])
{
// quantityConfigGERAN
// ...
}
if (quantityConfigOpts[0])
{
// quantityConfigCDMA2000
// ...
}
}
measConfig->haveMeasGapConfig = bitset11[3];
if (measConfig->haveMeasGapConfig)
{
// measGapConfig
int measGapConfigChoice;
bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator);
switch (measGapConfigChoice)
{
case 0:
measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET;
bIterator = DeserializeNull (bIterator);
break;
case 1:
default:
measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
int gapOffsetChoice;
bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator);
switch (gapOffsetChoice)
{
case 0:
measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::GP0;
bIterator = DeserializeInteger (&n, 0, 39, bIterator);
measConfig->measGapConfig.gapOffsetValue = n;
break;
case 1:
default:
measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::GP1;
bIterator = DeserializeInteger (&n, 0, 79, bIterator);
measConfig->measGapConfig.gapOffsetValue = n;
}
}
}
measConfig->haveSmeasure = bitset11[2];
if (measConfig->haveSmeasure)
{
// s-Measure
bIterator = DeserializeInteger (&n, 0, 97, bIterator);
measConfig->sMeasure = n;
}
if (bitset11[1])
{
// preRegistrationInfoHRPD
// ...
}
measConfig->haveSpeedStatePars = bitset11[0];
if (measConfig->haveSpeedStatePars)
{
// speedStatePars
int speedStateParsChoice;
bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterator);
switch (speedStateParsChoice)
{
case 0:
measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET;
bIterator = DeserializeNull (bIterator);
break;
case 1:
default:
measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP;
bIterator = DeserializeSequence (&bitset0, false, bIterator);
// Deserialize mobilityStateParameters
// Deserialize t-Evaluation
bIterator = DeserializeEnum (8, &n, bIterator);
switch (n)
{
case 0:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30;
break;
case 1:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 60;
break;
case 2:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 120;
break;
case 3:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 180;
break;
case 4:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 240;
break;
default:
measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0;
}
// Deserialize t-HystNormal
bIterator = DeserializeEnum (8, &n, bIterator);
switch (n)
{
case 0:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30;
break;
case 1:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 60;
break;
case 2:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 120;
break;
case 3:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 180;
break;
case 4:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 240;
break;
default:
measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0;
}
bIterator = DeserializeInteger (&n, 1, 16, bIterator);
measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n;
bIterator = DeserializeInteger (&n, 1, 16, bIterator);
measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n;
// Deserialize timeToTriggerSf
bIterator = DeserializeEnum (4, &n, bIterator);
measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25;
bIterator = DeserializeEnum (4, &n, bIterator);
measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25;
}
}
return bIterator;
}
//////////////////// RrcConnectionRequest class ////////////////////////
// Constructor
RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage ()
{
m_mmec = std::bitset<8> (0ul);
m_mTmsi = std::bitset<32> (0ul);
m_establishmentCause = MO_SIGNALLING;
m_spare = std::bitset<1> (0ul);
}
// Destructor
RrcConnectionRequestHeader::~RrcConnectionRequestHeader ()
{
}
TypeId
RrcConnectionRequestHeader::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RrcConnectionRequestHeader")
.SetParent<Header> ()
.SetGroupName("Lte")
;
return tid;
}
void
RrcConnectionRequestHeader::Print (std::ostream &os) const
{
os << "MMEC:" << m_mmec << std::endl;
os << "MTMSI:" << m_mTmsi << std::endl;
os << "EstablishmentCause:" << m_establishmentCause << std::endl;
os << "Spare: " << m_spare << std::endl;
}
void
RrcConnectionRequestHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
SerializeUlCcchMessage (1);
// Serialize RRCConnectionRequest sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice:
// 2 options, selected: 0 (option: rrcConnectionRequest-r8)
SerializeChoice (2,0,false);
// Serialize RRCConnectionRequest-r8-IEs sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize InitialUE-Identity choice:
// 2 options, selected: 0 (option: s-TMSI)
SerializeChoice (2,0,false);
// Serialize S-TMSI sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize mmec : MMEC ::= BIT STRING (SIZE (8))
SerializeBitstring (m_mmec);
// Serialize m-TMSI ::= BIT STRING (SIZE (32))
SerializeBitstring (m_mTmsi);
// Serialize establishmentCause : EstablishmentCause ::= ENUMERATED
SerializeEnum (8,m_establishmentCause);
// Serialize spare : BIT STRING (SIZE (1))
SerializeBitstring (std::bitset<1> ());
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionRequestHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<1> dummy;
std::bitset<0> optionalOrDefaultMask;
int selectedOption;
bIterator = DeserializeUlCcchMessage (bIterator);
// Deserialize RCConnectionRequest sequence
bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator);
// Deserialize criticalExtensions choice:
bIterator = DeserializeChoice (2,false,&selectedOption,bIterator);
// Deserialize RRCConnectionRequest-r8-IEs sequence
bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator);
// Deserialize InitialUE-Identity choice
bIterator = DeserializeChoice (2,false,&selectedOption,bIterator);
// Deserialize S-TMSI sequence
bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator);
// Deserialize mmec
bIterator = DeserializeBitstring (&m_mmec,bIterator);
// Deserialize m-TMSI
bIterator = DeserializeBitstring (&m_mTmsi,bIterator);
// Deserialize establishmentCause
bIterator = DeserializeEnum (8,&selectedOption,bIterator);
// Deserialize spare
bIterator = DeserializeBitstring (&dummy,bIterator);
return GetSerializedSize ();
}
void
RrcConnectionRequestHeader::SetMessage (LteRrcSap::RrcConnectionRequest msg)
{
m_mTmsi = std::bitset<32> ((uint32_t)msg.ueIdentity);
m_mmec = std::bitset<8> ((uint32_t)(msg.ueIdentity >> 32));
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionRequest
RrcConnectionRequestHeader::GetMessage () const
{
LteRrcSap::RrcConnectionRequest msg;
msg.ueIdentity = (((uint64_t) m_mmec.to_ulong ()) << 32) | (m_mTmsi.to_ulong ());
return msg;
}
std::bitset<8>
RrcConnectionRequestHeader::GetMmec () const
{
return m_mmec;
}
std::bitset<32>
RrcConnectionRequestHeader::GetMtmsi () const
{
return m_mTmsi;
}
//////////////////// RrcConnectionSetup class ////////////////////////
RrcConnectionSetupHeader::RrcConnectionSetupHeader ()
{
}
RrcConnectionSetupHeader::~RrcConnectionSetupHeader ()
{
}
void
RrcConnectionSetupHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
os << "radioResourceConfigDedicated:" << std::endl;
RrcAsn1Header::Print (os,m_radioResourceConfigDedicated);
}
void
RrcConnectionSetupHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
SerializeDlCcchMessage (3);
SerializeInteger (15,0,15);
// Serialize RRCConnectionSetup sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier ::=INTEGER (0..3)
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice:
// 2 options, selected: 0 (option: c1)
SerializeChoice (2,0,false);
// Serialize c1 choice:
// 8 options, selected: 0 (option: rrcConnectionSetup-r8)
SerializeChoice (8,0,false);
// Serialize rrcConnectionSetup-r8 sequence
// 1 optional fields (not present). Extension marker not present.
SerializeSequence (std::bitset<1> (0),false);
// Serialize RadioResourceConfigDedicated sequence
SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
// Serialize nonCriticalExtension sequence
// 2 optional fields, none present. No extension marker.
SerializeSequence (std::bitset<2> (0),false);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionSetupHeader::Deserialize (Buffer::Iterator bIterator)
{
int n;
std::bitset<0> bitset0;
std::bitset<1> bitset1;
std::bitset<2> bitset2;
bIterator = DeserializeDlCcchMessage (bIterator);
bIterator = DeserializeInteger (&n,0,15,bIterator);
// Deserialize RRCConnectionSetup sequence
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3)
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
// Deserialize criticalExtensions choice
int criticalExtensionChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator);
if (criticalExtensionChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionChoice == 0)
{
// Deserialize c1
int c1;
bIterator = DeserializeChoice (8,false,&c1,bIterator);
if (c1 > 0)
{
// Deserialize spareX , X:=7..1
bIterator = DeserializeNull (bIterator);
}
else if (c1 == 0)
{
// Deserialize rrcConnectionSetup-r8
// 1 optional fields, no extension marker.
bIterator = DeserializeSequence (&bitset1,false,bIterator);
// Deserialize radioResourceConfigDedicated
bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
if (bitset1[0])
{
// Deserialize nonCriticalExtension
// 2 optional fields, no extension marker.
bIterator = DeserializeSequence (&bitset2,false,bIterator);
// Deserialization of lateR8NonCriticalExtension and nonCriticalExtension
// ...
}
}
}
return GetSerializedSize ();
}
void
RrcConnectionSetupHeader::SetMessage (LteRrcSap::RrcConnectionSetup msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionSetup
RrcConnectionSetupHeader::GetMessage () const
{
LteRrcSap::RrcConnectionSetup msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
return msg;
}
uint8_t
RrcConnectionSetupHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
bool
RrcConnectionSetupHeader::HavePhysicalConfigDedicated () const
{
return m_radioResourceConfigDedicated.havePhysicalConfigDedicated;
}
std::list<LteRrcSap::SrbToAddMod>
RrcConnectionSetupHeader::GetSrbToAddModList () const
{
return m_radioResourceConfigDedicated.srbToAddModList;
}
std::list<LteRrcSap::DrbToAddMod>
RrcConnectionSetupHeader::GetDrbToAddModList () const
{
return m_radioResourceConfigDedicated.drbToAddModList;
}
std::list<uint8_t>
RrcConnectionSetupHeader::GetDrbToReleaseList () const
{
return m_radioResourceConfigDedicated.drbToReleaseList;
}
LteRrcSap::PhysicalConfigDedicated
RrcConnectionSetupHeader::GetPhysicalConfigDedicated () const
{
return m_radioResourceConfigDedicated.physicalConfigDedicated;
}
LteRrcSap::RadioResourceConfigDedicated
RrcConnectionSetupHeader::GetRadioResourceConfigDedicated () const
{
return m_radioResourceConfigDedicated;
}
//////////////////// RrcConnectionSetupCompleteHeader class ////////////////////////
RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader ()
{
}
RrcConnectionSetupCompleteHeader::~RrcConnectionSetupCompleteHeader ()
{
}
void
RrcConnectionSetupCompleteHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize DCCH message
SerializeUlDcchMessage (4);
// Serialize RRCConnectionSetupComplete sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
// 2 options, selected 0 (c1)
SerializeChoice (2,0,false);
// Choose spare3 NULL
SerializeChoice (4,1,false);
// Serialize spare3 NULL
SerializeNull ();
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
bIterator = DeserializeUlDcchMessage (bIterator);
bIterator = DeserializeSequence (&bitset0,false,bIterator);
int n;
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (n == 0)
{
// Deserialize c1
int c1Chosen;
bIterator = DeserializeChoice (4,false,&c1Chosen,bIterator);
if (c1Chosen == 0)
{
// Deserialize rrcConnectionSetupComplete-r8
// ...
}
else
{
bIterator = DeserializeNull (bIterator);
}
}
return GetSerializedSize ();
}
void
RrcConnectionSetupCompleteHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
}
void
RrcConnectionSetupCompleteHeader::SetMessage (LteRrcSap::RrcConnectionSetupCompleted msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_isDataSerialized = false;
}
uint8_t
RrcConnectionSetupCompleteHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
LteRrcSap::RrcConnectionSetupCompleted
RrcConnectionSetupCompleteHeader::GetMessage () const
{
LteRrcSap::RrcConnectionSetupCompleted msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
return msg;
}
//////////////////// RrcConnectionReconfigurationCompleteHeader class ////////////////////////
RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader ()
{
}
RrcConnectionReconfigurationCompleteHeader::~RrcConnectionReconfigurationCompleteHeader ()
{
}
void
RrcConnectionReconfigurationCompleteHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize DCCH message
SerializeUlDcchMessage (2);
// Serialize RRCConnectionSetupComplete sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
// 2 options, selected 1 (criticalExtensionsFuture)
SerializeChoice (2,1,false);
// Choose criticalExtensionsFuture
SerializeSequence (std::bitset<0> (),false);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeUlDcchMessage (bIterator);
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (n == 0)
{
// Deserialize rrcConnectionReconfigurationComplete-r8
// ...
}
return GetSerializedSize ();
}
void
RrcConnectionReconfigurationCompleteHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
}
void
RrcConnectionReconfigurationCompleteHeader::SetMessage (LteRrcSap::RrcConnectionReconfigurationCompleted msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReconfigurationCompleted
RrcConnectionReconfigurationCompleteHeader::GetMessage () const
{
LteRrcSap::RrcConnectionReconfigurationCompleted msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
return msg;
}
uint8_t
RrcConnectionReconfigurationCompleteHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
//////////////////// RrcConnectionReconfigurationHeader class ////////////////////////
RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader ()
{
}
RrcConnectionReconfigurationHeader::~RrcConnectionReconfigurationHeader ()
{
}
void
RrcConnectionReconfigurationHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
SerializeDlDcchMessage (4);
// Serialize RRCConnectionSetupComplete sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
// 2 options, selected 0 (c1)
SerializeChoice (2,0,false);
// Serialize c1 choice
// 8 options, selected 0 (rrcConnectionReconfiguration-r8)
SerializeChoice (8,0,false);
// Serialize RRCConnectionReconfiguration-r8-IEs sequence:
// 6 optional fields. Extension marker not present.
std::bitset<6> options;
options.set (5,m_haveMeasConfig);
options.set (4,m_haveMobilityControlInfo);
options.set (3,0); // No dedicatedInfoNASList
options.set (2,m_haveRadioResourceConfigDedicated);
options.set (1,0); // No securityConfigHO
options.set (0,m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility with R10 - CA
SerializeSequence (options,false);
if (m_haveMeasConfig)
{
SerializeMeasConfig (m_measConfig);
}
if (m_haveMobilityControlInfo)
{
// Serialize MobilityControlInfo
// 4 optional fields, extension marker present.
std::bitset<4> mobCtrlIntoOptional;
mobCtrlIntoOptional.set (3,m_mobilityControlInfo.haveCarrierFreq);
mobCtrlIntoOptional.set (2,m_mobilityControlInfo.haveCarrierBandwidth);
mobCtrlIntoOptional.set (1,0); // No additionalSpectrumEmission
mobCtrlIntoOptional.set (0,m_mobilityControlInfo.haveRachConfigDedicated);
SerializeSequence (mobCtrlIntoOptional,true);
// Serialize targetPhysCellId
SerializeInteger (m_mobilityControlInfo.targetPhysCellId,0,503);
if (m_mobilityControlInfo.haveCarrierFreq)
{
SerializeSequence (std::bitset<1> (1),false);
SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,MAX_EARFCN);
SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,MAX_EARFCN);
}
if (m_mobilityControlInfo.haveCarrierBandwidth)
{
SerializeSequence (std::bitset<1> (1),false);
// Serialize dl-Bandwidth
switch (m_mobilityControlInfo.carrierBandwidth.dlBandwidth)
{
case 6:
SerializeEnum (16,0);
break;
case 15:
SerializeEnum (16,1);
break;
case 25:
SerializeEnum (16,2);
break;
case 50:
SerializeEnum (16,3);
break;
case 75:
SerializeEnum (16,4);
break;
case 100:
SerializeEnum (16,5);
break;
default:
SerializeEnum (16,6);
}
// Serialize ul-Bandwidth
switch (m_mobilityControlInfo.carrierBandwidth.ulBandwidth)
{
case 6:
SerializeEnum (16,0);
break;
case 15:
SerializeEnum (16,1);
break;
case 25:
SerializeEnum (16,2);
break;
case 50:
SerializeEnum (16,3);
break;
case 75:
SerializeEnum (16,4);
break;
case 100:
SerializeEnum (16,5);
break;
default:
SerializeEnum (16,6);
}
}
// Serialize t304
SerializeEnum (8,0);
// Serialize newUE-Identitiy
SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity));
// Serialize radioResourceConfigCommon
SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceConfigCommon);
if (m_mobilityControlInfo.haveRachConfigDedicated)
{
SerializeSequence (std::bitset<0> (),false);
SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex,0,63);
SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex,0,15);
}
}
if (m_haveRadioResourceConfigDedicated)
{
// Serialize RadioResourceConfigDedicated
SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
}
if (m_haveNonCriticalExtension)
{
// Serialize NonCriticalExtension RRCConnectionReconfiguration-v890-IEs sequence:
// 2 optional fields. Extension marker not present.
std::bitset<2> noncriticalExtension_v890;
noncriticalExtension_v890.set (1,0); // No lateNonCriticalExtension
noncriticalExtension_v890.set (0,m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility with R10 - CA
//Enable RRCCoonectionReconfiguration-v920-IEs
SerializeSequence (noncriticalExtension_v890,false);
// Serialize NonCriticalExtension RRCConnectionReconfiguration-v920-IEs sequence:
// 3 optional fields. Extension marker not present.
std::bitset<3> noncriticalExtension_v920;
noncriticalExtension_v920.set (1,0); // No otehrConfig-r9
noncriticalExtension_v920.set (1,0); // No fullConfig-r9
//Enable RRCCoonectionReconfiguration-v1020-IEs
noncriticalExtension_v920.set (0,m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility with R10 - CA
SerializeSequence (noncriticalExtension_v920,false);
SerializeNonCriticalExtensionConfiguration (m_nonCriticalExtension); //Serializing RRCConnectionReconfiguration-r8-IEs
}
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReconfigurationHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
bIterator = DeserializeDlDcchMessage (bIterator);
// RRCConnectionReconfiguration sequence
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// rrc-TransactionIdentifier
int n;
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
// criticalExtensions
int sel;
bIterator = DeserializeChoice (2,false,&sel,bIterator);
if (sel == 1)
{
// criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (sel == 0)
{
// c1
int c1Chosen;
bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator);
if (c1Chosen > 0)
{
bIterator = DeserializeNull (bIterator);
}
else if (c1Chosen == 0)
{
// rrcConnectionReconfiguration-r8
std::bitset<6> rrcConnRecOpts;
bIterator = DeserializeSequence (&rrcConnRecOpts,false,bIterator);
m_haveMeasConfig = rrcConnRecOpts[5];
if (m_haveMeasConfig)
{
bIterator = DeserializeMeasConfig (&m_measConfig, bIterator);
}
m_haveMobilityControlInfo = rrcConnRecOpts[4];
if (m_haveMobilityControlInfo)
{
// mobilityControlInfo
std::bitset<4> mobCtrlOpts;
bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator);
// PhysCellId
bIterator = DeserializeInteger (&n,0,503,bIterator);
m_mobilityControlInfo.targetPhysCellId = n;
// carrierFreq
m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3];
if (m_mobilityControlInfo.haveCarrierFreq)
{
std::bitset<1> ulCarrierFreqPresent;
bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,bIterator);
bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n;
if (ulCarrierFreqPresent[0])
{
bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n;
}
}
// carrierBandwidth
m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2];
if (m_mobilityControlInfo.haveCarrierBandwidth)
{
std::bitset<1> ulBandwidthPresent;
bIterator = DeserializeSequence (&ulBandwidthPresent,false,bIterator);
bIterator = DeserializeEnum (16,&n,bIterator);
switch (n)
{
case 0:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 6;
break;
case 1:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 15;
break;
case 2:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 25;
break;
case 3:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 50;
break;
case 4:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 75;
break;
case 5:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 100;
break;
case 6:
m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 0;
break;
}
if (ulBandwidthPresent[0])
{
bIterator = DeserializeEnum (16,&n,bIterator);
switch (n)
{
case 0:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 6;
break;
case 1:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 15;
break;
case 2:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 25;
break;
case 3:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 50;
break;
case 4:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 75;
break;
case 5:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 100;
break;
case 6:
m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 0;
break;
}
}
}
// additionalSpectrumEmission
if (mobCtrlOpts[1])
{
// ...
}
// t304
bIterator = DeserializeEnum (8,&n,bIterator);
// newUE-Identity
std::bitset<16> cRnti;
bIterator = DeserializeBitstring (&cRnti, bIterator);
m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong ();
// radioResourceConfigCommon
bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityControlInfo.radioResourceConfigCommon, bIterator);
m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0];
if (m_mobilityControlInfo.haveRachConfigDedicated)
{
bIterator = DeserializeSequence (&bitset0, false, bIterator);
bIterator = DeserializeInteger (&n,0,63, bIterator);
m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = n;
bIterator = DeserializeInteger (&n,0,15, bIterator);
m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = n;
}
}
// dedicatedInfoNASList
if (rrcConnRecOpts[3])
{
// ...
}
// radioResourceConfigDedicated
m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2];
if (m_haveRadioResourceConfigDedicated)
{
bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
}
// securityConfigHO
if (rrcConnRecOpts[1])
{
// ...
}
// nonCriticalExtension
m_haveNonCriticalExtension = rrcConnRecOpts[0];
if (m_haveNonCriticalExtension)
{
bIterator = DeserializeNonCriticalExtensionConfig (&m_nonCriticalExtension,bIterator);
// ...
}
}
}
return GetSerializedSize ();
}
void
RrcConnectionReconfigurationHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
os << "haveMeasConfig: " << m_haveMeasConfig << std::endl;
if (m_haveMeasConfig)
{
if (!m_measConfig.measObjectToRemoveList.empty ())
{
os << " measObjectToRemoveList: ";
std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
std::list<uint8_t>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << (int) *it << ", ";
}
os << std::endl;
}
if (!m_measConfig.reportConfigToRemoveList.empty ())
{
os << " reportConfigToRemoveList: ";
std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
std::list<uint8_t>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << (int) *it << ", ";
}
os << std::endl;
}
if (!m_measConfig.measIdToRemoveList.empty ())
{
os << " measIdToRemoveList: ";
std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
std::list<uint8_t>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << (int) *it << ", ";
}
os << std::endl;
}
if (!m_measConfig.measObjectToAddModList.empty ())
{
os << " measObjectToAddMod: " << std::endl;
std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.measObjectToAddModList;
std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << " measObjectId: " << (int)it->measObjectId << std::endl;
os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl;
os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth << std::endl;
os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1 << std::endl;
os << " neighCellConfig: " << (int) it->measObjectEutra.neighCellConfig << std::endl;
os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl;
if (!it->measObjectEutra.cellsToRemoveList.empty ())
{
os << " cellsToRemoveList: ";
std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemoveList;
std::list<uint8_t>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << (int) *it << ", ";
}
os << std::endl;
}
if (!it->measObjectEutra.blackCellsToRemoveList.empty ())
{
os << " blackCellsToRemoveList: ";
std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToRemoveList;
std::list<uint8_t>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << (int) *it << ", ";
}
os << std::endl;
}
if (!it->measObjectEutra.cellsToAddModList.empty ())
{
os << " cellsToAddModList: " << std::endl;
std::list<LteRrcSap::CellsToAddMod> auxList = it->measObjectEutra.cellsToAddModList;
std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << " cellIndex: " << (int)it->cellIndex << std::endl;
os << " physCellId: " << (int)it->physCellId << std::endl;
os << " cellIndividualOffset: " << (int)it->cellIndividualOffset << std::endl;
os << " ------ " << std::endl;
}
}
if (!it->measObjectEutra.blackCellsToAddModList.empty ())
{
os << " blackCellsToAddModList: " << std::endl;
std::list<LteRrcSap::BlackCellsToAddMod> auxList = it->measObjectEutra.blackCellsToAddModList;
std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << " cellIndex: " << (int)it->cellIndex << std::endl;
os << " physCellIdRange.start: " << (int)it->physCellIdRange.start << std::endl;
os << " physCellIdRange.haveRange: " << it->physCellIdRange.haveRange << std::endl;
os << " physCellIdRange.range: " << (int)it->physCellIdRange.range << std::endl;
os << " ------ " << std::endl;
}
}
os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl;
os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl;
os << " ------------- " << std::endl;
}
}
if (!m_measConfig.reportConfigToAddModList.empty ())
{
os << " reportConfigToAddModList: " << std::endl;
std::list<LteRrcSap::ReportConfigToAddMod> auxList = m_measConfig.reportConfigToAddModList;
std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
os << " reportConfigEutra.triggerType " << (int)it->reportConfigEutra.triggerType << std::endl;
if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEutra::EVENT)
{
os << " reportConfigEutra.eventId " << (int)it->reportConfigEutra.eventId << std::endl;
if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A3)
{
os << " reportConfigEutra.reportOnLeave " << (int)it->reportConfigEutra.reportOnLeave << std::endl;
os << " reportConfigEutra.a3Offset " << (int)it->reportConfigEutra.a3Offset << std::endl;
}
else
{
os << " reportConfigEutra.threshold1.choice " << (int)it->reportConfigEutra.threshold1.choice << std::endl;
os << " reportConfigEutra.threshold1.range " << (int)it->reportConfigEutra.threshold1.range << std::endl;
if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A5)
{
os << " reportConfigEutra.threshold2.choice " << (int)it->reportConfigEutra.threshold2.choice << std::endl;
os << " reportConfigEutra.threshold2.range " << (int)it->reportConfigEutra.threshold2.range << std::endl;
}
}
os << " reportConfigEutra.hysteresis " << (int)it->reportConfigEutra.hysteresis << std::endl;
os << " reportConfigEutra.timeToTrigger " << (int)it->reportConfigEutra.timeToTrigger << std::endl;
}
else
{
os << " reportConfigEutra.purpose " << (int)it->reportConfigEutra.purpose << std::endl;
}
os << " reportConfigEutra.triggerQuantity " << (int)it->reportConfigEutra.triggerQuantity << std::endl;
os << " reportConfigEutra.reportQuantity " << (int)it->reportConfigEutra.reportQuantity << std::endl;
os << " reportConfigEutra.maxReportCells " << (int)it->reportConfigEutra.maxReportCells << std::endl;
os << " reportConfigEutra.reportInterval " << (int)it->reportConfigEutra.reportInterval << std::endl;
os << " reportConfigEutra.reportAmount " << (int)it->reportConfigEutra.reportAmount << std::endl;
}
}
if (!m_measConfig.measIdToAddModList.empty ())
{
os << " measIdToAddModList: " << std::endl;
std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdToAddModList;
std::list<LteRrcSap::MeasIdToAddMod>::iterator it = auxList.begin ();
for (; it != auxList.end (); it++)
{
os << " measId: " << (int)it->measId << std::endl;
os << " measObjectId: " << (int)it->measObjectId << std::endl;
os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
os << " ------ " << std::endl;
}
}
os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl;
if (m_measConfig.haveQuantityConfig)
{
os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl;
os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl;
}
os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl;
if (m_measConfig.haveMeasGapConfig)
{
os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl;
os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice
<< "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl;
}
os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl;
if (m_measConfig.haveSmeasure)
{
os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl;
}
os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl;
if (m_measConfig.haveSpeedStatePars)
{
os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl;
os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl;
os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl;
os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl;
os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl;
os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl;
os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl;
}
}
os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl;
if (m_haveMobilityControlInfo)
{
os << "targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellId << std::endl;
os << "haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << std::endl;
if (m_mobilityControlInfo.haveCarrierFreq)
{
os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo.carrierFreq.dlCarrierFreq << std::endl;
os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo.carrierFreq.ulCarrierFreq << std::endl;
}
os << "haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandwidth << std::endl;
if (m_mobilityControlInfo.haveCarrierBandwidth)
{
os << " carrierBandwidth.dlBandwidth: " << (int) m_mobilityControlInfo.carrierBandwidth.dlBandwidth << std::endl;
os << " carrierBandwidth.ulBandwidth: " << (int) m_mobilityControlInfo.carrierBandwidth.ulBandwidth << std::endl;
}
os << "newUeIdentity: " << (int) m_mobilityControlInfo.newUeIdentity << std::endl;
os << "haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfigDedicated << std::endl;
if (m_mobilityControlInfo.haveRachConfigDedicated)
{
os << "raPreambleIndex: " << (int) m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex << std::endl;
os << "raPrachMaskIndex: " << (int) m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex << std::endl;
}
}
os << "haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedicated << std::endl;
if (m_haveRadioResourceConfigDedicated)
{
RrcAsn1Header::Print (os,m_radioResourceConfigDedicated);
}
}
void
RrcConnectionReconfigurationHeader::SetMessage (LteRrcSap::RrcConnectionReconfiguration msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_haveMeasConfig = msg.haveMeasConfig;
m_measConfig = msg.measConfig;
m_haveMobilityControlInfo = msg.haveMobilityControlInfo;
m_mobilityControlInfo = msg.mobilityControlInfo;
m_haveRadioResourceConfigDedicated = msg.haveRadioResourceConfigDedicated;
m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
m_haveNonCriticalExtension = msg.haveNonCriticalExtension;
m_nonCriticalExtension = msg.nonCriticalExtension;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReconfiguration
RrcConnectionReconfigurationHeader::GetMessage () const
{
LteRrcSap::RrcConnectionReconfiguration msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
msg.haveMeasConfig = m_haveMeasConfig;
msg.measConfig = m_measConfig;
msg.haveMobilityControlInfo = m_haveMobilityControlInfo;
msg.mobilityControlInfo = m_mobilityControlInfo;
msg.haveRadioResourceConfigDedicated = m_haveRadioResourceConfigDedicated;
msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
msg.haveNonCriticalExtension = m_haveNonCriticalExtension;
msg.nonCriticalExtension = m_nonCriticalExtension;
return msg;
}
uint8_t
RrcConnectionReconfigurationHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
bool
RrcConnectionReconfigurationHeader::GetHaveMeasConfig ()
{
return m_haveMeasConfig;
}
LteRrcSap::MeasConfig
RrcConnectionReconfigurationHeader::GetMeasConfig ()
{
return m_measConfig;
}
bool
RrcConnectionReconfigurationHeader::GetHaveMobilityControlInfo ()
{
return m_haveMobilityControlInfo;
}
LteRrcSap::MobilityControlInfo
RrcConnectionReconfigurationHeader::GetMobilityControlInfo ()
{
return m_mobilityControlInfo;
}
bool
RrcConnectionReconfigurationHeader::GetHaveRadioResourceConfigDedicated ()
{
return m_haveRadioResourceConfigDedicated;
}
LteRrcSap::RadioResourceConfigDedicated
RrcConnectionReconfigurationHeader::GetRadioResourceConfigDedicated ()
{
return m_radioResourceConfigDedicated;
}
bool
RrcConnectionReconfigurationHeader::GetHaveNonCriticalExtensionConfig ()
{
return m_haveNonCriticalExtension;
}
LteRrcSap::NonCriticalExtensionConfiguration
RrcConnectionReconfigurationHeader::GetNonCriticalExtensionConfig ()
{
return m_nonCriticalExtension;
}
bool
RrcConnectionReconfigurationHeader::HavePhysicalConfigDedicated () const
{
return m_radioResourceConfigDedicated.havePhysicalConfigDedicated;
}
std::list<LteRrcSap::SrbToAddMod>
RrcConnectionReconfigurationHeader::GetSrbToAddModList () const
{
return m_radioResourceConfigDedicated.srbToAddModList;
}
std::list<LteRrcSap::DrbToAddMod>
RrcConnectionReconfigurationHeader::GetDrbToAddModList () const
{
return m_radioResourceConfigDedicated.drbToAddModList;
}
std::list<uint8_t>
RrcConnectionReconfigurationHeader::GetDrbToReleaseList () const
{
return m_radioResourceConfigDedicated.drbToReleaseList;
}
LteRrcSap::PhysicalConfigDedicated
RrcConnectionReconfigurationHeader::GetPhysicalConfigDedicated () const
{
return m_radioResourceConfigDedicated.physicalConfigDedicated;
}
//////////////////// HandoverPreparationInfoHeader class ////////////////////////
HandoverPreparationInfoHeader::HandoverPreparationInfoHeader ()
{
}
void
HandoverPreparationInfoHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize HandoverPreparationInformation sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice
// 2 options, selected 0 (c1)
SerializeChoice (2,0,false);
// Serialize c1 choice
// 8 options, selected 0 (handoverPreparationInformation-r8)
SerializeChoice (8,0,false);
// Serialize HandoverPreparationInformation-r8-IEs sequence
// 4 optional fields, no extension marker.
std::bitset<4> handoverPrepInfoOpts;
handoverPrepInfoOpts.set (3,1); // as-Config present
handoverPrepInfoOpts.set (2,0); // rrm-Config not present
handoverPrepInfoOpts.set (1,0); // as-Context not present
handoverPrepInfoOpts.set (0,0); // nonCriticalExtension not present
SerializeSequence (handoverPrepInfoOpts,false);
// Serialize ue-RadioAccessCapabilityInfo
SerializeSequenceOf (0,MAX_RAT_CAPABILITIES,0);
// Serialize as-Config
SerializeSequence (std::bitset<0> (),true);
// Serialize sourceMeasConfig
SerializeMeasConfig (m_asConfig.sourceMeasConfig);
// Serialize sourceRadioResourceConfig
SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig);
// Serialize sourceSecurityAlgorithmConfig
SerializeSequence (std::bitset<0> (),false);
// cipheringAlgorithm
SerializeEnum (8,0);
// integrityProtAlgorithm
SerializeEnum (8,0);
// Serialize sourceUE-Identity
SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity));
// Serialize sourceMasterInformationBlock
SerializeSequence (std::bitset<0> (),false);
SerializeEnum (6,m_asConfig.sourceMasterInformationBlock.dlBandwidth); // dl-Bandwidth
SerializeSequence (std::bitset<0> (),false); // phich-Config sequence
SerializeEnum (2,0); // phich-Duration
SerializeEnum (4,0); // phich-Resource
SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.systemFrameNumber)); // systemFrameNumber
SerializeBitstring (std::bitset<10> (321)); // spare
// Serialize sourceSystemInformationBlockType1 sequence
SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBlockType1);
// Serialize sourceSystemInformationBlockType2
SerializeSystemInformationBlockType2 (m_asConfig.sourceSystemInformationBlockType2);
// Serialize AntennaInfoCommon
SerializeSequence (std::bitset<0> (0),false);
SerializeEnum (4,0); // antennaPortsCount
// Serialize sourceDlCarrierFreq
SerializeInteger (m_asConfig.sourceDlCarrierFreq,0,MAX_EARFCN);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
HandoverPreparationInfoHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
// Deserialize HandoverPreparationInformation sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize criticalExtensions choice
int criticalExtensionsChosen;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChosen,bIterator);
if (criticalExtensionsChosen == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChosen == 0)
{
// Deserialize c1 choice
int c1Chosen;
bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator);
if (c1Chosen > 0)
{
bIterator = DeserializeNull (bIterator);
}
else if (c1Chosen == 0)
{
// Deserialize handoverPreparationInformation-r8
std::bitset<4> handoverPrepInfoOpts;
bIterator = DeserializeSequence (&handoverPrepInfoOpts,false,bIterator);
// Deserialize ue-RadioAccessCapabilityInfo
bIterator = DeserializeSequenceOf (&n,MAX_RAT_CAPABILITIES,0,bIterator);
for (int i = 0; i < n; i++)
{
// Deserialize UE-CapabilityRAT-Container
// ...
}
if (handoverPrepInfoOpts[3])
{
// Deserialize as-Config sequence
bIterator = DeserializeSequence (&bitset0,true,bIterator);
// Deserialize sourceMeasConfig
bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, bIterator);
// Deserialize sourceRadioResourceConfig
bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.sourceRadioResourceConfig,bIterator);
// Deserialize sourceSecurityAlgorithmConfig
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorithm
bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgorithm
// Deserialize sourceUE-Identity
std::bitset<16> cRnti;
bIterator = DeserializeBitstring (&cRnti,bIterator);
m_asConfig.sourceUeIdentity = cRnti.to_ulong ();
// Deserialize sourceMasterInformationBlock
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth
m_asConfig.sourceMasterInformationBlock.dlBandwidth = n;
// phich-Config
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration
bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource
// systemFrameNumber
std::bitset<8> systemFrameNumber;
bIterator = DeserializeBitstring (&systemFrameNumber,bIterator);
m_asConfig.sourceMasterInformationBlock.systemFrameNumber = systemFrameNumber.to_ulong ();
// spare
std::bitset<10> spare;
bIterator = DeserializeBitstring (&spare,bIterator);
// Deserialize sourceSystemInformationBlockType1
bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.sourceSystemInformationBlockType1,bIterator);
// Deserialize sourceSystemInformationBlockType2
bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.sourceSystemInformationBlockType2,bIterator);
// Deserialize antennaInfoCommon
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeEnum (4,&n,bIterator); // antennaPortsCount
// Deserialize sourceDl-CarrierFreq
bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
m_asConfig.sourceDlCarrierFreq = n;
}
if (handoverPrepInfoOpts[2])
{
// Deserialize rrm-Config
// ...
}
if (handoverPrepInfoOpts[1])
{
// Deserialize as-Context
// ...
}
if (handoverPrepInfoOpts[0])
{
// Deserialize nonCriticalExtension
// ...
}
}
}
return GetSerializedSize ();
}
void
HandoverPreparationInfoHeader::Print (std::ostream &os) const
{
RrcAsn1Header::Print (os,m_asConfig.sourceRadioResourceConfig);
os << "sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl;
os << "dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBandwidth << std::endl;
os << "systemFrameNumber: " << (int)m_asConfig.sourceMasterInformationBlock.systemFrameNumber << std::endl;
os << "plmnIdentityInfo.plmnIdentity: " << (int) m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity << std::endl;
os << "cellAccessRelatedInfo.cellIdentity " << (int)m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity << std::endl;
os << "cellAccessRelatedInfo.csgIndication: " << m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication << std::endl;
os << "cellAccessRelatedInfo.csgIdentity: " << (int)m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity << std::endl;
os << "sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl;
}
void
HandoverPreparationInfoHeader::SetMessage (LteRrcSap::HandoverPreparationInfo msg)
{
m_asConfig = msg.asConfig;
m_isDataSerialized = false;
}
LteRrcSap::HandoverPreparationInfo
HandoverPreparationInfoHeader::GetMessage () const
{
LteRrcSap::HandoverPreparationInfo msg;
msg.asConfig = m_asConfig;
return msg;
}
LteRrcSap::AsConfig
HandoverPreparationInfoHeader::GetAsConfig () const
{
return m_asConfig;
}
//////////////////// RrcConnectionReestablishmentRequestHeader class ////////////////////////
RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader ()
{
}
RrcConnectionReestablishmentRequestHeader::~RrcConnectionReestablishmentRequestHeader ()
{
}
void
RrcConnectionReestablishmentRequestHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
SerializeUlCcchMessage (0);
// Serialize RrcConnectionReestablishmentReques sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice
// chosen: rrcConnectionReestablishmentRequest-r8
SerializeChoice (2,0,false);
// Serialize RRCConnectionReestablishmentRequest-r8-IEs sequence
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize ue-Identity
SerializeSequence (std::bitset<0> (),false);
// Serialize c-RNTI
SerializeBitstring (std::bitset<16> (m_ueIdentity.cRnti));
// Serialize physCellId
SerializeInteger (m_ueIdentity.physCellId,0,503);
// Serialize shortMAC-I
SerializeBitstring (std::bitset<16> (0));
// Serialize ReestablishmentCause
switch (m_reestablishmentCause)
{
case LteRrcSap::RECONFIGURATION_FAILURE:
SerializeEnum (4,0);
break;
case LteRrcSap::HANDOVER_FAILURE:
SerializeEnum (4,1);
break;
case LteRrcSap::OTHER_FAILURE:
SerializeEnum (4,2);
break;
default:
SerializeEnum (4,3);
}
// Serialize spare
SerializeBitstring (std::bitset<2> (0));
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReestablishmentRequestHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeUlCcchMessage (bIterator);
// Deserialize RrcConnectionReestablishmentRequest sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize criticalExtensions choice
bIterator = DeserializeChoice (2,false,&n,bIterator);
if ( n == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if ( n == 0)
{
// Deserialize RRCConnectionReestablishmentRequest-r8-IEs
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize ReestabUE-Identity sequence
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize c-RNTI
std::bitset<16> cRnti;
bIterator = DeserializeBitstring (&cRnti,bIterator);
m_ueIdentity.cRnti = cRnti.to_ulong ();
// Deserialize physCellId
int physCellId;
bIterator = DeserializeInteger (&physCellId,0,503,bIterator);
m_ueIdentity.physCellId = physCellId;
// Deserialize shortMAC-I
std::bitset<16> shortMacI;
bIterator = DeserializeBitstring (&shortMacI,bIterator);
// Deserialize ReestablishmentCause
int reestCs;
bIterator = DeserializeEnum (4,&reestCs,bIterator);
switch (reestCs)
{
case 0:
m_reestablishmentCause = LteRrcSap::RECONFIGURATION_FAILURE;
break;
case 1:
m_reestablishmentCause = LteRrcSap::HANDOVER_FAILURE;
break;
case 2:
m_reestablishmentCause = LteRrcSap::OTHER_FAILURE;
break;
case 3:
break;
}
// Deserialize spare
std::bitset<2> spare;
bIterator = DeserializeBitstring (&spare,bIterator);
}
return GetSerializedSize ();
}
void
RrcConnectionReestablishmentRequestHeader::Print (std::ostream &os) const
{
os << "ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl;
os << "ueIdentity.physCellId: " << (int)m_ueIdentity.physCellId << std::endl;
os << "m_reestablishmentCause: " << m_reestablishmentCause << std::endl;
}
void
RrcConnectionReestablishmentRequestHeader::SetMessage (LteRrcSap::RrcConnectionReestablishmentRequest msg)
{
m_ueIdentity = msg.ueIdentity;
m_reestablishmentCause = msg.reestablishmentCause;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReestablishmentRequest
RrcConnectionReestablishmentRequestHeader::GetMessage () const
{
LteRrcSap::RrcConnectionReestablishmentRequest msg;
msg.ueIdentity = m_ueIdentity;
msg.reestablishmentCause = m_reestablishmentCause;
return msg;
}
LteRrcSap::ReestabUeIdentity
RrcConnectionReestablishmentRequestHeader::GetUeIdentity () const
{
return m_ueIdentity;
}
LteRrcSap::ReestablishmentCause
RrcConnectionReestablishmentRequestHeader::GetReestablishmentCause () const
{
return m_reestablishmentCause;
}
//////////////////// RrcConnectionReestablishmentHeader class ////////////////////////
RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader ()
{
}
RrcConnectionReestablishmentHeader::~RrcConnectionReestablishmentHeader ()
{
}
void
RrcConnectionReestablishmentHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
SerializeDlCcchMessage (0);
// Serialize RrcConnectionReestablishment sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
SerializeChoice (2,0,false);
// Serialize c1 choice
SerializeChoice (8,0,false);
// Serialize RRCConnectionReestablishment-r8-IEs sequence
// 1 optional field, no extension marker
SerializeSequence (std::bitset<1> (0),false);
// Serialize radioResourceConfigDedicated
SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
// Serialize nextHopChainingCount
SerializeInteger (0,0,7);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReestablishmentHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeDlCcchMessage (bIterator);
// Deserialize RrcConnectionReestablishment sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize rrc-TransactionIdentifier
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
// Deserialize criticalExtensions choice
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize c1
int c1;
bIterator = DeserializeChoice (8,false,&c1,bIterator);
if (c1 > 0)
{
bIterator = DeserializeNull (bIterator);
}
else if (c1 == 0)
{
// Deserialize rrcConnectionReestablishment-r8
// 1 optional field
std::bitset<1> nonCriticalExtensionPresent;
bIterator = DeserializeSequence (&nonCriticalExtensionPresent,false,bIterator);
// Deserialize RadioResourceConfigDedicated
bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
// Deserialize nextHopChainingCount
bIterator = DeserializeInteger (&n,0,7,bIterator);
}
}
return GetSerializedSize ();
}
void
RrcConnectionReestablishmentHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
os << "RadioResourceConfigDedicated: " << std::endl;
RrcAsn1Header::Print (os,m_radioResourceConfigDedicated);
}
void
RrcConnectionReestablishmentHeader::SetMessage (LteRrcSap::RrcConnectionReestablishment msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReestablishment
RrcConnectionReestablishmentHeader::GetMessage () const
{
LteRrcSap::RrcConnectionReestablishment msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
return msg;
}
uint8_t
RrcConnectionReestablishmentHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
LteRrcSap::RadioResourceConfigDedicated
RrcConnectionReestablishmentHeader::GetRadioResourceConfigDedicated () const
{
return m_radioResourceConfigDedicated;
}
//////////////////// RrcConnectionReestablishmentCompleteHeader class ////////////////////////
RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader ()
{
}
void
RrcConnectionReestablishmentCompleteHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize DCCH message
SerializeUlDcchMessage (3);
// Serialize RrcConnectionReestablishmentComplete sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
SerializeChoice (2,0,false);
// Serialize rrcConnectionReestablishmentComplete-r8 sequence
// 1 optional field (not present), no extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReestablishmentCompleteHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeUlDcchMessage (bIterator);
// Deserialize RrcConnectionReestablishmentComplete sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize rrc-TransactionIdentifier
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcTransactionIdentifier = n;
// Deserialize criticalExtensions choice
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize rrcConnectionReestablishmentComplete-r8
std::bitset<1> opts;
bIterator = DeserializeSequence (&opts,false,bIterator);
if (opts[0])
{
// Deserialize RRCConnectionReestablishmentComplete-v920-IEs
// ...
}
}
return GetSerializedSize ();
}
void
RrcConnectionReestablishmentCompleteHeader::Print (std::ostream &os) const
{
os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
}
void
RrcConnectionReestablishmentCompleteHeader::SetMessage (LteRrcSap::RrcConnectionReestablishmentComplete msg)
{
m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReestablishmentComplete
RrcConnectionReestablishmentCompleteHeader::GetMessage () const
{
LteRrcSap::RrcConnectionReestablishmentComplete msg;
msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
return msg;
}
uint8_t
RrcConnectionReestablishmentCompleteHeader::GetRrcTransactionIdentifier () const
{
return m_rrcTransactionIdentifier;
}
//////////////////// RrcConnectionReestablishmentRejectHeader class ////////////////////////
RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader ()
{
}
RrcConnectionReestablishmentRejectHeader::~RrcConnectionReestablishmentRejectHeader ()
{
}
void
RrcConnectionReestablishmentRejectHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize CCCH message
SerializeDlCcchMessage (1);
// Serialize RrcConnectionReestablishmentReject sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice
SerializeChoice (2,0,false);
// Serialize RRCConnectionReestablishmentReject-r8-IEs sequence
// 1 optional field (not present), no extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReestablishmentRejectHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
bIterator = DeserializeDlCcchMessage (bIterator);
// Deserialize RrcConnectionReestablishmentReject sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize criticalExtensions choice
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize rrcConnectionReestablishmentReject-r8
std::bitset<1> opts;
bIterator = DeserializeSequence (&opts,false,bIterator);
if (opts[0])
{
// Deserialize RRCConnectionReestablishmentReject-v8a0-IEs
// ...
}
}
return GetSerializedSize ();
}
void
RrcConnectionReestablishmentRejectHeader::Print (std::ostream &os) const
{
}
void
RrcConnectionReestablishmentRejectHeader::SetMessage (LteRrcSap::RrcConnectionReestablishmentReject msg)
{
m_rrcConnectionReestablishmentReject = msg;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReestablishmentReject
RrcConnectionReestablishmentRejectHeader::GetMessage () const
{
return m_rrcConnectionReestablishmentReject;
}
//////////////////// RrcConnectionReleaseHeader class ////////////////////////
RrcConnectionReleaseHeader::RrcConnectionReleaseHeader ()
{
}
RrcConnectionReleaseHeader::~RrcConnectionReleaseHeader ()
{
}
void
RrcConnectionReleaseHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize DCCH message
SerializeDlDcchMessage (5);
// Serialize RrcConnectionRelease sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize rrc-TransactionIdentifier
SerializeInteger (m_rrcConnectionRelease.rrcTransactionIdentifier,0,3);
// Serialize criticalExtensions choice
SerializeChoice (2,0,false);
// Serialize c1 choice
SerializeChoice (4,0,false);
// Serialize RRCConnectionRelease-r8-IEs sequence
// 3 optional field (not present), no extension marker.
SerializeSequence (std::bitset<3> (0),false);
// Serialize ReleaseCause
SerializeEnum (4,1);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionReleaseHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeDlDcchMessage (bIterator);
// Deserialize RrcConnectionRelease sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize rrc-TransactionIdentifier
bIterator = DeserializeInteger (&n,0,3,bIterator);
m_rrcConnectionRelease.rrcTransactionIdentifier = n;
// Deserialize criticalExtensions choice
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize c1
int c1Choice;
bIterator = DeserializeChoice (4,false,&c1Choice,bIterator);
if (c1Choice == 0)
{
// Deserialize RRCConnectionRelease-r8-IEs
std::bitset<3> opts;
bIterator = DeserializeSequence (&opts,false,bIterator);
// Deserialize releaseCause
bIterator = DeserializeEnum (4,&n,bIterator);
if (opts[2])
{
// Deserialize redirectedCarrierInfo
// ...
}
if (opts[1])
{
// Deserialize idleModeMobilityControlInfo
// ...
}
if (opts[0])
{
// Deserialize nonCriticalExtension
// ...
}
}
else
{
bIterator = DeserializeNull (bIterator);
}
}
return GetSerializedSize ();
}
void
RrcConnectionReleaseHeader::Print (std::ostream &os) const
{
}
void
RrcConnectionReleaseHeader::SetMessage (LteRrcSap::RrcConnectionRelease msg)
{
m_rrcConnectionRelease = msg;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionRelease
RrcConnectionReleaseHeader::GetMessage () const
{
return m_rrcConnectionRelease;
}
//////////////////// RrcConnectionRejectHeader class ////////////////////////
RrcConnectionRejectHeader::RrcConnectionRejectHeader ()
{
}
RrcConnectionRejectHeader::~RrcConnectionRejectHeader ()
{
}
void
RrcConnectionRejectHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize CCCH message
SerializeDlCcchMessage (2);
// Serialize RrcConnectionReject sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice
SerializeChoice (2,0,false);
// Serialize c1 choice
SerializeChoice (4,0,false);
// Serialize rrcConnectionReject-r8 sequence
// 1 optional field (not present), no extension marker.
SerializeSequence (std::bitset<1> (0),false);
// Serialize waitTime
SerializeInteger (m_rrcConnectionReject.waitTime, 1, 16);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
RrcConnectionRejectHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeDlCcchMessage (bIterator);
// Deserialize RrcConnectionReject sequence
// 0 optional fields, no extension marker
bIterator = DeserializeSequence (&bitset0,false,bIterator);
// Deserialize criticalExtensions choice
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize c1 choice
int c1Choice;
bIterator = DeserializeChoice (4,false,&c1Choice,bIterator);
if (c1Choice > 0)
{
bIterator = DeserializeNull (bIterator);
}
else if (c1Choice == 0)
{
// Deserialize rrcConnectionReject-r8
std::bitset<1> opts;
bIterator = DeserializeSequence (&opts,false,bIterator);
bIterator = DeserializeInteger (&n,1,16,bIterator);
m_rrcConnectionReject.waitTime = n;
if (opts[0])
{
// Deserialize RRCConnectionReject-v8a0-IEs
// ...
}
}
}
return GetSerializedSize ();
}
void
RrcConnectionRejectHeader::Print (std::ostream &os) const
{
os << "wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl;
}
void
RrcConnectionRejectHeader::SetMessage (LteRrcSap::RrcConnectionReject msg)
{
m_rrcConnectionReject = msg;
m_isDataSerialized = false;
}
LteRrcSap::RrcConnectionReject
RrcConnectionRejectHeader::GetMessage () const
{
return m_rrcConnectionReject;
}
//////////////////// MeasurementReportHeader class ////////////////////////
MeasurementReportHeader::MeasurementReportHeader ()
{
}
MeasurementReportHeader::~MeasurementReportHeader ()
{
}
void
MeasurementReportHeader::PreSerialize () const
{
m_serializationResult = Buffer ();
// Serialize DCCH message
SerializeUlDcchMessage (1);
// Serialize MeasurementReport sequence:
// no default or optional fields. Extension marker not present.
SerializeSequence (std::bitset<0> (),false);
// Serialize criticalExtensions choice:
// c1 chosen
SerializeChoice (2,0,false);
// Serialize c1 choice
// measurementReport-r8 chosen
SerializeChoice (8,0,false);
// Serialize MeasurementReport-r8-IEs sequence:
// 1 optional fields, not present. Extension marker not present.
SerializeSequence (std::bitset<1> (0),false);
// Serialize measResults
SerializeMeasResults (m_measurementReport.measResults);
// Finish serialization
FinalizeSerialization ();
}
uint32_t
MeasurementReportHeader::Deserialize (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeUlDcchMessage (bIterator);
int criticalExtensionsChoice;
bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator);
if (criticalExtensionsChoice == 1)
{
// Deserialize criticalExtensionsFuture
bIterator = DeserializeSequence (&bitset0,false,bIterator);
}
else if (criticalExtensionsChoice == 0)
{
// Deserialize c1
int c1Choice;
bIterator = DeserializeChoice (8,false,&c1Choice,bIterator);
if (c1Choice > 0)
{
bIterator = DeserializeNull (bIterator);
}
else
{
// Deserialize measurementReport-r8
std::bitset<1> isNonCriticalExtensionPresent;
bIterator = DeserializeSequence (&isNonCriticalExtensionPresent,false,bIterator);
// Deserialize measResults
bIterator = DeserializeMeasResults (&m_measurementReport.measResults, bIterator);
if (isNonCriticalExtensionPresent[0])
{
// Deserialize nonCriticalExtension MeasurementReport-v8a0-IEs
// ...
}
}
}
return GetSerializedSize ();
}
void
MeasurementReportHeader::Print (std::ostream &os) const
{
os << "measId = " << (int)m_measurementReport.measResults.measId << std::endl;
os << "rsrpResult = " << (int)m_measurementReport.measResults.rsrpResult << std::endl;
os << "rsrqResult = " << (int)m_measurementReport.measResults.rsrqResult << std::endl;
os << "haveMeasResultNeighCells = " << (int)m_measurementReport.measResults.haveMeasResultNeighCells << std::endl;
if (m_measurementReport.measResults.haveMeasResultNeighCells)
{
std::list<LteRrcSap::MeasResultEutra> measResultListEutra = m_measurementReport.measResults.measResultListEutra;
std::list<LteRrcSap::MeasResultEutra>::iterator it = measResultListEutra.begin ();
for (; it != measResultListEutra.end (); it++)
{
os << " physCellId =" << (int) it->physCellId << std::endl;
os << " haveCgiInfo =" << it->haveCgiInfo << std::endl;
if (it->haveCgiInfo)
{
os << " plmnIdentity = " << (int) it->cgiInfo.plmnIdentity << std::endl;
os << " cellIdentity = " << (int) it->cgiInfo.cellIdentity << std::endl;
os << " trackingAreaCode = " << (int) it->cgiInfo.trackingAreaCode << std::endl;
os << " havePlmnIdentityList = " << !it->cgiInfo.plmnIdentityList.empty () << std::endl;
if (!it->cgiInfo.plmnIdentityList.empty ())
{
for (std::list<uint32_t>::iterator it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it->cgiInfo.plmnIdentityList.end (); it2++)
{
os << " plmnId : " << *it2 << std::endl;
}
}
}
os << " haveRsrpResult =" << it->haveRsrpResult << std::endl;
if (it->haveRsrpResult)
{
os << " rsrpResult =" << (int) it->rsrpResult << std::endl;
}
os << " haveRsrqResult =" << it->haveRsrqResult << std::endl;
if (it->haveRsrqResult)
{
os << " rsrqResult =" << (int) it->rsrqResult << std::endl;
}
}
}
}
void
MeasurementReportHeader::SetMessage (LteRrcSap::MeasurementReport msg)
{
m_measurementReport = msg;
m_isDataSerialized = false;
}
LteRrcSap::MeasurementReport
MeasurementReportHeader::GetMessage () const
{
LteRrcSap::MeasurementReport msg;
msg = m_measurementReport;
return msg;
}
/////////////////// RrcUlDcchMessage //////////////////////////////////
RrcUlDcchMessage::RrcUlDcchMessage () : RrcAsn1Header ()
{
}
RrcUlDcchMessage::~RrcUlDcchMessage ()
{
}
uint32_t
RrcUlDcchMessage::Deserialize (Buffer::Iterator bIterator)
{
DeserializeUlDcchMessage (bIterator);
return 1;
}
void
RrcUlDcchMessage::Print (std::ostream &os) const
{
std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl;
}
void
RrcUlDcchMessage::PreSerialize () const
{
SerializeUlDcchMessage (m_messageType);
}
Buffer::Iterator
RrcUlDcchMessage::DeserializeUlDcchMessage (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize messageClassExtension
bIterator = DeserializeSequence (&bitset0,false,bIterator);
m_messageType = -1;
}
else if (n == 0)
{
// Deserialize c1
bIterator = DeserializeChoice (16,false,&m_messageType,bIterator);
}
return bIterator;
}
void
RrcUlDcchMessage::SerializeUlDcchMessage (int messageType) const
{
SerializeSequence (std::bitset<0> (),false);
// Choose c1
SerializeChoice (2,0,false);
// Choose message type
SerializeChoice (16,messageType,false);
}
/////////////////// RrcDlDcchMessage //////////////////////////////////
RrcDlDcchMessage::RrcDlDcchMessage () : RrcAsn1Header ()
{
}
RrcDlDcchMessage::~RrcDlDcchMessage ()
{
}
uint32_t
RrcDlDcchMessage::Deserialize (Buffer::Iterator bIterator)
{
DeserializeDlDcchMessage (bIterator);
return 1;
}
void
RrcDlDcchMessage::Print (std::ostream &os) const
{
std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl;
}
void
RrcDlDcchMessage::PreSerialize () const
{
SerializeDlDcchMessage (m_messageType);
}
Buffer::Iterator
RrcDlDcchMessage::DeserializeDlDcchMessage (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize messageClassExtension
bIterator = DeserializeSequence (&bitset0,false,bIterator);
m_messageType = -1;
}
else if (n == 0)
{
// Deserialize c1
bIterator = DeserializeChoice (16,false,&m_messageType,bIterator);
}
return bIterator;
}
void
RrcDlDcchMessage::SerializeDlDcchMessage (int messageType) const
{
SerializeSequence (std::bitset<0> (),false);
// Choose c1
SerializeChoice (2,0,false);
// Choose message type
SerializeChoice (16,messageType,false);
}
/////////////////// RrcUlCcchMessage //////////////////////////////////
RrcUlCcchMessage::RrcUlCcchMessage () : RrcAsn1Header ()
{
}
RrcUlCcchMessage::~RrcUlCcchMessage ()
{
}
uint32_t
RrcUlCcchMessage::Deserialize (Buffer::Iterator bIterator)
{
DeserializeUlCcchMessage (bIterator);
return 1;
}
void
RrcUlCcchMessage::Print (std::ostream &os) const
{
std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl;
}
void
RrcUlCcchMessage::PreSerialize () const
{
SerializeUlCcchMessage (m_messageType);
}
Buffer::Iterator
RrcUlCcchMessage::DeserializeUlCcchMessage (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize messageClassExtension
bIterator = DeserializeSequence (&bitset0,false,bIterator);
m_messageType = -1;
}
else if (n == 0)
{
// Deserialize c1
bIterator = DeserializeChoice (2,false,&m_messageType,bIterator);
}
return bIterator;
}
void
RrcUlCcchMessage::SerializeUlCcchMessage (int messageType) const
{
SerializeSequence (std::bitset<0> (),false);
// Choose c1
SerializeChoice (2,0,false);
// Choose message type
SerializeChoice (2,messageType,false);
}
/////////////////// RrcDlCcchMessage //////////////////////////////////
RrcDlCcchMessage::RrcDlCcchMessage () : RrcAsn1Header ()
{
}
RrcDlCcchMessage::~RrcDlCcchMessage ()
{
}
uint32_t
RrcDlCcchMessage::Deserialize (Buffer::Iterator bIterator)
{
DeserializeDlCcchMessage (bIterator);
return 1;
}
void
RrcDlCcchMessage::Print (std::ostream &os) const
{
std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl;
}
void
RrcDlCcchMessage::PreSerialize () const
{
SerializeDlCcchMessage (m_messageType);
}
Buffer::Iterator
RrcDlCcchMessage::DeserializeDlCcchMessage (Buffer::Iterator bIterator)
{
std::bitset<0> bitset0;
int n;
bIterator = DeserializeSequence (&bitset0,false,bIterator);
bIterator = DeserializeChoice (2,false,&n,bIterator);
if (n == 1)
{
// Deserialize messageClassExtension
bIterator = DeserializeSequence (&bitset0,false,bIterator);
m_messageType = -1;
}
else if (n == 0)
{
// Deserialize c1
bIterator = DeserializeChoice (4,false,&m_messageType,bIterator);
}
return bIterator;
}
void
RrcDlCcchMessage::SerializeDlCcchMessage (int messageType) const
{
SerializeSequence (std::bitset<0> (),false);
// Choose c1
SerializeChoice (2,0,false);
// Choose message type
SerializeChoice (4,messageType,false);
}
} // namespace ns3
| gpl-2.0 |
wkritzinger/asuswrt-merlin | release/src/router/ffmpeg/libswscale/x86/rgb2rgb_template.c | 108140 | /*
* software RGB to RGB converter
* pluralize by software PAL8 to RGB converter
* software YUV to YUV converter
* software YUV to RGB converter
* Written by Nick Kurshev.
* palette & YUV & runtime CPU stuff by Michael ([email protected])
* lot of big-endian byte order fixes by Alex Beregszaszi
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stddef.h>
#undef PREFETCH
#undef MOVNTQ
#undef EMMS
#undef SFENCE
#undef PAVGB
#if COMPILE_TEMPLATE_AMD3DNOW
#define PREFETCH "prefetch"
#define PAVGB "pavgusb"
#elif COMPILE_TEMPLATE_MMX2
#define PREFETCH "prefetchnta"
#define PAVGB "pavgb"
#else
#define PREFETCH " # nop"
#endif
#if COMPILE_TEMPLATE_AMD3DNOW
/* On K6 femms is faster than emms. On K7 femms is directly mapped to emms. */
#define EMMS "femms"
#else
#define EMMS "emms"
#endif
#if COMPILE_TEMPLATE_MMX2
#define MOVNTQ "movntq"
#define SFENCE "sfence"
#else
#define MOVNTQ "movq"
#define SFENCE " # nop"
#endif
#if !COMPILE_TEMPLATE_SSE2
#if !COMPILE_TEMPLATE_AMD3DNOW
static inline void RENAME(rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size)
{
uint8_t *dest = dst;
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
mm_end = end - 23;
__asm__ volatile("movq %0, %%mm7"::"m"(mask32a):"memory");
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"punpckldq 3%1, %%mm0 \n\t"
"movd 6%1, %%mm1 \n\t"
"punpckldq 9%1, %%mm1 \n\t"
"movd 12%1, %%mm2 \n\t"
"punpckldq 15%1, %%mm2 \n\t"
"movd 18%1, %%mm3 \n\t"
"punpckldq 21%1, %%mm3 \n\t"
"por %%mm7, %%mm0 \n\t"
"por %%mm7, %%mm1 \n\t"
"por %%mm7, %%mm2 \n\t"
"por %%mm7, %%mm3 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
MOVNTQ" %%mm1, 8%0 \n\t"
MOVNTQ" %%mm2, 16%0 \n\t"
MOVNTQ" %%mm3, 24%0"
:"=m"(*dest)
:"m"(*s)
:"memory");
dest += 32;
s += 24;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
*dest++ = *s++;
*dest++ = *s++;
*dest++ = *s++;
*dest++ = 255;
}
}
#define STORE_BGR24_MMX \
"psrlq $8, %%mm2 \n\t" \
"psrlq $8, %%mm3 \n\t" \
"psrlq $8, %%mm6 \n\t" \
"psrlq $8, %%mm7 \n\t" \
"pand "MANGLE(mask24l)", %%mm0\n\t" \
"pand "MANGLE(mask24l)", %%mm1\n\t" \
"pand "MANGLE(mask24l)", %%mm4\n\t" \
"pand "MANGLE(mask24l)", %%mm5\n\t" \
"pand "MANGLE(mask24h)", %%mm2\n\t" \
"pand "MANGLE(mask24h)", %%mm3\n\t" \
"pand "MANGLE(mask24h)", %%mm6\n\t" \
"pand "MANGLE(mask24h)", %%mm7\n\t" \
"por %%mm2, %%mm0 \n\t" \
"por %%mm3, %%mm1 \n\t" \
"por %%mm6, %%mm4 \n\t" \
"por %%mm7, %%mm5 \n\t" \
\
"movq %%mm1, %%mm2 \n\t" \
"movq %%mm4, %%mm3 \n\t" \
"psllq $48, %%mm2 \n\t" \
"psllq $32, %%mm3 \n\t" \
"pand "MANGLE(mask24hh)", %%mm2\n\t" \
"pand "MANGLE(mask24hhh)", %%mm3\n\t" \
"por %%mm2, %%mm0 \n\t" \
"psrlq $16, %%mm1 \n\t" \
"psrlq $32, %%mm4 \n\t" \
"psllq $16, %%mm5 \n\t" \
"por %%mm3, %%mm1 \n\t" \
"pand "MANGLE(mask24hhhh)", %%mm5\n\t" \
"por %%mm5, %%mm4 \n\t" \
\
MOVNTQ" %%mm0, %0 \n\t" \
MOVNTQ" %%mm1, 8%0 \n\t" \
MOVNTQ" %%mm4, 16%0"
static inline void RENAME(rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
{
uint8_t *dest = dst;
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
mm_end = end - 31;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq 8%1, %%mm1 \n\t"
"movq 16%1, %%mm4 \n\t"
"movq 24%1, %%mm5 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm1, %%mm3 \n\t"
"movq %%mm4, %%mm6 \n\t"
"movq %%mm5, %%mm7 \n\t"
STORE_BGR24_MMX
:"=m"(*dest)
:"m"(*s)
:"memory");
dest += 24;
s += 32;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
*dest++ = *s++;
*dest++ = *s++;
*dest++ = *s++;
s++;
}
}
/*
original by Strepto/Astral
ported to gcc & bugfixed: A'rpi
MMX2, 3DNOW optimization by Nick Kurshev
32-bit C version, and and&add trick by Michael Niedermayer
*/
static inline void RENAME(rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size)
{
register const uint8_t* s=src;
register uint8_t* d=dst;
register const uint8_t *end;
const uint8_t *mm_end;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*s));
__asm__ volatile("movq %0, %%mm4"::"m"(mask15s));
mm_end = end - 15;
while (s<mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq 8%1, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"pand %%mm4, %%mm0 \n\t"
"pand %%mm4, %%mm2 \n\t"
"paddw %%mm1, %%mm0 \n\t"
"paddw %%mm3, %%mm2 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
MOVNTQ" %%mm2, 8%0"
:"=m"(*d)
:"m"(*s)
);
d+=16;
s+=16;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
mm_end = end - 3;
while (s < mm_end) {
register unsigned x= *((const uint32_t *)s);
*((uint32_t *)d) = (x&0x7FFF7FFF) + (x&0x7FE07FE0);
d+=4;
s+=4;
}
if (s < end) {
register unsigned short x= *((const uint16_t *)s);
*((uint16_t *)d) = (x&0x7FFF) + (x&0x7FE0);
}
}
static inline void RENAME(rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size)
{
register const uint8_t* s=src;
register uint8_t* d=dst;
register const uint8_t *end;
const uint8_t *mm_end;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*s));
__asm__ volatile("movq %0, %%mm7"::"m"(mask15rg));
__asm__ volatile("movq %0, %%mm6"::"m"(mask15b));
mm_end = end - 15;
while (s<mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq 8%1, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlq $1, %%mm0 \n\t"
"psrlq $1, %%mm2 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm3 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm3, %%mm2 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
MOVNTQ" %%mm2, 8%0"
:"=m"(*d)
:"m"(*s)
);
d+=16;
s+=16;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
mm_end = end - 3;
while (s < mm_end) {
register uint32_t x= *((const uint32_t*)s);
*((uint32_t *)d) = ((x>>1)&0x7FE07FE0) | (x&0x001F001F);
s+=4;
d+=4;
}
if (s < end) {
register uint16_t x= *((const uint16_t*)s);
*((uint16_t *)d) = ((x>>1)&0x7FE0) | (x&0x001F);
}
}
static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
mm_end = end - 15;
#if 1 //is faster only if multiplies are reasonably fast (FIXME figure out on which CPUs this is faster, on Athlon it is slightly faster)
__asm__ volatile(
"movq %3, %%mm5 \n\t"
"movq %4, %%mm6 \n\t"
"movq %5, %%mm7 \n\t"
"jmp 2f \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1) \n\t"
"movd (%1), %%mm0 \n\t"
"movd 4(%1), %%mm3 \n\t"
"punpckldq 8(%1), %%mm0 \n\t"
"punpckldq 12(%1), %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm3, %%mm4 \n\t"
"pand %%mm6, %%mm0 \n\t"
"pand %%mm6, %%mm3 \n\t"
"pmaddwd %%mm7, %%mm0 \n\t"
"pmaddwd %%mm7, %%mm3 \n\t"
"pand %%mm5, %%mm1 \n\t"
"pand %%mm5, %%mm4 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"psrld $5, %%mm0 \n\t"
"pslld $11, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, (%0) \n\t"
"add $16, %1 \n\t"
"add $8, %0 \n\t"
"2: \n\t"
"cmp %2, %1 \n\t"
" jb 1b \n\t"
: "+r" (d), "+r"(s)
: "r" (mm_end), "m" (mask3216g), "m" (mask3216br), "m" (mul3216)
);
#else
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_16mask),"m"(green_16mask));
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 4%1, %%mm3 \n\t"
"punpckldq 8%1, %%mm0 \n\t"
"punpckldq 12%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psrlq $3, %%mm0 \n\t"
"psrlq $3, %%mm3 \n\t"
"pand %2, %%mm0 \n\t"
"pand %2, %%mm3 \n\t"
"psrlq $5, %%mm1 \n\t"
"psrlq $5, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $8, %%mm2 \n\t"
"psrlq $8, %%mm5 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
d += 4;
s += 16;
}
#endif
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register int rgb = *(const uint32_t*)s; s += 4;
*d++ = ((rgb&0xFF)>>3) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>8);
}
}
static inline void RENAME(rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_16mask),"m"(green_16mask));
mm_end = end - 15;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 4%1, %%mm3 \n\t"
"punpckldq 8%1, %%mm0 \n\t"
"punpckldq 12%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psllq $8, %%mm0 \n\t"
"psllq $8, %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm3 \n\t"
"psrlq $5, %%mm1 \n\t"
"psrlq $5, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $19, %%mm2 \n\t"
"psrlq $19, %%mm5 \n\t"
"pand %2, %%mm2 \n\t"
"pand %2, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
d += 4;
s += 16;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register int rgb = *(const uint32_t*)s; s += 4;
*d++ = ((rgb&0xF8)<<8) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>19);
}
}
static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
mm_end = end - 15;
#if 1 //is faster only if multiplies are reasonably fast (FIXME figure out on which CPUs this is faster, on Athlon it is slightly faster)
__asm__ volatile(
"movq %3, %%mm5 \n\t"
"movq %4, %%mm6 \n\t"
"movq %5, %%mm7 \n\t"
"jmp 2f \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1) \n\t"
"movd (%1), %%mm0 \n\t"
"movd 4(%1), %%mm3 \n\t"
"punpckldq 8(%1), %%mm0 \n\t"
"punpckldq 12(%1), %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm3, %%mm4 \n\t"
"pand %%mm6, %%mm0 \n\t"
"pand %%mm6, %%mm3 \n\t"
"pmaddwd %%mm7, %%mm0 \n\t"
"pmaddwd %%mm7, %%mm3 \n\t"
"pand %%mm5, %%mm1 \n\t"
"pand %%mm5, %%mm4 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"psrld $6, %%mm0 \n\t"
"pslld $10, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, (%0) \n\t"
"add $16, %1 \n\t"
"add $8, %0 \n\t"
"2: \n\t"
"cmp %2, %1 \n\t"
" jb 1b \n\t"
: "+r" (d), "+r"(s)
: "r" (mm_end), "m" (mask3215g), "m" (mask3216br), "m" (mul3215)
);
#else
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_15mask),"m"(green_15mask));
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 4%1, %%mm3 \n\t"
"punpckldq 8%1, %%mm0 \n\t"
"punpckldq 12%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psrlq $3, %%mm0 \n\t"
"psrlq $3, %%mm3 \n\t"
"pand %2, %%mm0 \n\t"
"pand %2, %%mm3 \n\t"
"psrlq $6, %%mm1 \n\t"
"psrlq $6, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $9, %%mm2 \n\t"
"psrlq $9, %%mm5 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 16;
}
#endif
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register int rgb = *(const uint32_t*)s; s += 4;
*d++ = ((rgb&0xFF)>>3) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>9);
}
}
static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 15;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 4%1, %%mm3 \n\t"
"punpckldq 8%1, %%mm0 \n\t"
"punpckldq 12%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psllq $7, %%mm0 \n\t"
"psllq $7, %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm3 \n\t"
"psrlq $6, %%mm1 \n\t"
"psrlq $6, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $19, %%mm2 \n\t"
"psrlq $19, %%mm5 \n\t"
"pand %2, %%mm2 \n\t"
"pand %2, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 16;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register int rgb = *(const uint32_t*)s; s += 4;
*d++ = ((rgb&0xF8)<<7) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>19);
}
}
static inline void RENAME(rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_16mask),"m"(green_16mask));
mm_end = end - 11;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 3%1, %%mm3 \n\t"
"punpckldq 6%1, %%mm0 \n\t"
"punpckldq 9%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psrlq $3, %%mm0 \n\t"
"psrlq $3, %%mm3 \n\t"
"pand %2, %%mm0 \n\t"
"pand %2, %%mm3 \n\t"
"psrlq $5, %%mm1 \n\t"
"psrlq $5, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $8, %%mm2 \n\t"
"psrlq $8, %%mm5 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
d += 4;
s += 12;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
const int b = *s++;
const int g = *s++;
const int r = *s++;
*d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
}
}
static inline void RENAME(rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_16mask),"m"(green_16mask));
mm_end = end - 15;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 3%1, %%mm3 \n\t"
"punpckldq 6%1, %%mm0 \n\t"
"punpckldq 9%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psllq $8, %%mm0 \n\t"
"psllq $8, %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm3 \n\t"
"psrlq $5, %%mm1 \n\t"
"psrlq $5, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $19, %%mm2 \n\t"
"psrlq $19, %%mm5 \n\t"
"pand %2, %%mm2 \n\t"
"pand %2, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
d += 4;
s += 12;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
const int r = *s++;
const int g = *s++;
const int b = *s++;
*d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
}
}
static inline void RENAME(rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 11;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 3%1, %%mm3 \n\t"
"punpckldq 6%1, %%mm0 \n\t"
"punpckldq 9%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psrlq $3, %%mm0 \n\t"
"psrlq $3, %%mm3 \n\t"
"pand %2, %%mm0 \n\t"
"pand %2, %%mm3 \n\t"
"psrlq $6, %%mm1 \n\t"
"psrlq $6, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $9, %%mm2 \n\t"
"psrlq $9, %%mm5 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 12;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
const int b = *s++;
const int g = *s++;
const int r = *s++;
*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
}
}
static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
"movq %0, %%mm7 \n\t"
"movq %1, %%mm6 \n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 15;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movd %1, %%mm0 \n\t"
"movd 3%1, %%mm3 \n\t"
"punpckldq 6%1, %%mm0 \n\t"
"punpckldq 9%1, %%mm3 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm3, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"psllq $7, %%mm0 \n\t"
"psllq $7, %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm3 \n\t"
"psrlq $6, %%mm1 \n\t"
"psrlq $6, %%mm4 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"psrlq $19, %%mm2 \n\t"
"psrlq $19, %%mm5 \n\t"
"pand %2, %%mm2 \n\t"
"pand %2, %%mm5 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm5, %%mm3 \n\t"
"psllq $16, %%mm3 \n\t"
"por %%mm3, %%mm0 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 12;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
const int r = *s++;
const int g = *s++;
const int b = *s++;
*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
}
}
/*
I use less accurate approximation here by simply left-shifting the input
value and filling the low order bits with zeroes. This method improves PNG
compression but this scheme cannot reproduce white exactly, since it does
not generate an all-ones maximum value; the net effect is to darken the
image slightly.
The better method should be "left bit replication":
4 3 2 1 0
---------
1 1 0 1 1
7 6 5 4 3 2 1 0
----------------
1 1 0 1 1 1 1 0
|=======| |===|
| leftmost bits repeated to fill open bits
|
original bits
*/
static inline void RENAME(rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint16_t *end;
const uint16_t *mm_end;
uint8_t *d = dst;
const uint16_t *s = (const uint16_t*)src;
end = s + src_size/2;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
mm_end = end - 7;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq %1, %%mm1 \n\t"
"movq %1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $2, %%mm1 \n\t"
"psrlq $7, %%mm2 \n\t"
"movq %%mm0, %%mm3 \n\t"
"movq %%mm1, %%mm4 \n\t"
"movq %%mm2, %%mm5 \n\t"
"punpcklwd %5, %%mm0 \n\t"
"punpcklwd %5, %%mm1 \n\t"
"punpcklwd %5, %%mm2 \n\t"
"punpckhwd %5, %%mm3 \n\t"
"punpckhwd %5, %%mm4 \n\t"
"punpckhwd %5, %%mm5 \n\t"
"psllq $8, %%mm1 \n\t"
"psllq $16, %%mm2 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm2, %%mm0 \n\t"
"psllq $8, %%mm4 \n\t"
"psllq $16, %%mm5 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm5, %%mm3 \n\t"
"movq %%mm0, %%mm6 \n\t"
"movq %%mm3, %%mm7 \n\t"
"movq 8%1, %%mm0 \n\t"
"movq 8%1, %%mm1 \n\t"
"movq 8%1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $2, %%mm1 \n\t"
"psrlq $7, %%mm2 \n\t"
"movq %%mm0, %%mm3 \n\t"
"movq %%mm1, %%mm4 \n\t"
"movq %%mm2, %%mm5 \n\t"
"punpcklwd %5, %%mm0 \n\t"
"punpcklwd %5, %%mm1 \n\t"
"punpcklwd %5, %%mm2 \n\t"
"punpckhwd %5, %%mm3 \n\t"
"punpckhwd %5, %%mm4 \n\t"
"punpckhwd %5, %%mm5 \n\t"
"psllq $8, %%mm1 \n\t"
"psllq $16, %%mm2 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm2, %%mm0 \n\t"
"psllq $8, %%mm4 \n\t"
"psllq $16, %%mm5 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm5, %%mm3 \n\t"
:"=m"(*d)
:"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r), "m"(mmx_null)
:"memory");
/* borrowed 32 to 24 */
__asm__ volatile(
"movq %%mm0, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"movq %%mm6, %%mm0 \n\t"
"movq %%mm7, %%mm1 \n\t"
"movq %%mm4, %%mm6 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm1, %%mm3 \n\t"
STORE_BGR24_MMX
:"=m"(*d)
:"m"(*s)
:"memory");
d += 24;
s += 8;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register uint16_t bgr;
bgr = *s++;
*d++ = (bgr&0x1F)<<3;
*d++ = (bgr&0x3E0)>>2;
*d++ = (bgr&0x7C00)>>7;
}
}
static inline void RENAME(rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint16_t *end;
const uint16_t *mm_end;
uint8_t *d = (uint8_t *)dst;
const uint16_t *s = (const uint16_t *)src;
end = s + src_size/2;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
mm_end = end - 7;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq %1, %%mm1 \n\t"
"movq %1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $3, %%mm1 \n\t"
"psrlq $8, %%mm2 \n\t"
"movq %%mm0, %%mm3 \n\t"
"movq %%mm1, %%mm4 \n\t"
"movq %%mm2, %%mm5 \n\t"
"punpcklwd %5, %%mm0 \n\t"
"punpcklwd %5, %%mm1 \n\t"
"punpcklwd %5, %%mm2 \n\t"
"punpckhwd %5, %%mm3 \n\t"
"punpckhwd %5, %%mm4 \n\t"
"punpckhwd %5, %%mm5 \n\t"
"psllq $8, %%mm1 \n\t"
"psllq $16, %%mm2 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm2, %%mm0 \n\t"
"psllq $8, %%mm4 \n\t"
"psllq $16, %%mm5 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm5, %%mm3 \n\t"
"movq %%mm0, %%mm6 \n\t"
"movq %%mm3, %%mm7 \n\t"
"movq 8%1, %%mm0 \n\t"
"movq 8%1, %%mm1 \n\t"
"movq 8%1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $3, %%mm1 \n\t"
"psrlq $8, %%mm2 \n\t"
"movq %%mm0, %%mm3 \n\t"
"movq %%mm1, %%mm4 \n\t"
"movq %%mm2, %%mm5 \n\t"
"punpcklwd %5, %%mm0 \n\t"
"punpcklwd %5, %%mm1 \n\t"
"punpcklwd %5, %%mm2 \n\t"
"punpckhwd %5, %%mm3 \n\t"
"punpckhwd %5, %%mm4 \n\t"
"punpckhwd %5, %%mm5 \n\t"
"psllq $8, %%mm1 \n\t"
"psllq $16, %%mm2 \n\t"
"por %%mm1, %%mm0 \n\t"
"por %%mm2, %%mm0 \n\t"
"psllq $8, %%mm4 \n\t"
"psllq $16, %%mm5 \n\t"
"por %%mm4, %%mm3 \n\t"
"por %%mm5, %%mm3 \n\t"
:"=m"(*d)
:"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r),"m"(mmx_null)
:"memory");
/* borrowed 32 to 24 */
__asm__ volatile(
"movq %%mm0, %%mm4 \n\t"
"movq %%mm3, %%mm5 \n\t"
"movq %%mm6, %%mm0 \n\t"
"movq %%mm7, %%mm1 \n\t"
"movq %%mm4, %%mm6 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm1, %%mm3 \n\t"
STORE_BGR24_MMX
:"=m"(*d)
:"m"(*s)
:"memory");
d += 24;
s += 8;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register uint16_t bgr;
bgr = *s++;
*d++ = (bgr&0x1F)<<3;
*d++ = (bgr&0x7E0)>>3;
*d++ = (bgr&0xF800)>>8;
}
}
/*
* mm0 = 00 B3 00 B2 00 B1 00 B0
* mm1 = 00 G3 00 G2 00 G1 00 G0
* mm2 = 00 R3 00 R2 00 R1 00 R0
* mm6 = FF FF FF FF FF FF FF FF
* mm7 = 00 00 00 00 00 00 00 00
*/
#define PACK_RGB32 \
"packuswb %%mm7, %%mm0 \n\t" /* 00 00 00 00 B3 B2 B1 B0 */ \
"packuswb %%mm7, %%mm1 \n\t" /* 00 00 00 00 G3 G2 G1 G0 */ \
"packuswb %%mm7, %%mm2 \n\t" /* 00 00 00 00 R3 R2 R1 R0 */ \
"punpcklbw %%mm1, %%mm0 \n\t" /* G3 B3 G2 B2 G1 B1 G0 B0 */ \
"punpcklbw %%mm6, %%mm2 \n\t" /* FF R3 FF R2 FF R1 FF R0 */ \
"movq %%mm0, %%mm3 \n\t" \
"punpcklwd %%mm2, %%mm0 \n\t" /* FF R1 G1 B1 FF R0 G0 B0 */ \
"punpckhwd %%mm2, %%mm3 \n\t" /* FF R3 G3 B3 FF R2 G2 B2 */ \
MOVNTQ" %%mm0, %0 \n\t" \
MOVNTQ" %%mm3, 8%0 \n\t" \
static inline void RENAME(rgb15to32)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint16_t *end;
const uint16_t *mm_end;
uint8_t *d = dst;
const uint16_t *s = (const uint16_t *)src;
end = s + src_size/2;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
__asm__ volatile("pxor %%mm7,%%mm7 \n\t":::"memory");
__asm__ volatile("pcmpeqd %%mm6,%%mm6 \n\t":::"memory");
mm_end = end - 3;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq %1, %%mm1 \n\t"
"movq %1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $2, %%mm1 \n\t"
"psrlq $7, %%mm2 \n\t"
PACK_RGB32
:"=m"(*d)
:"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r)
:"memory");
d += 16;
s += 4;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register uint16_t bgr;
bgr = *s++;
*d++ = (bgr&0x1F)<<3;
*d++ = (bgr&0x3E0)>>2;
*d++ = (bgr&0x7C00)>>7;
*d++ = 255;
}
}
static inline void RENAME(rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint16_t *end;
const uint16_t *mm_end;
uint8_t *d = dst;
const uint16_t *s = (const uint16_t*)src;
end = s + src_size/2;
__asm__ volatile(PREFETCH" %0"::"m"(*s):"memory");
__asm__ volatile("pxor %%mm7,%%mm7 \n\t":::"memory");
__asm__ volatile("pcmpeqd %%mm6,%%mm6 \n\t":::"memory");
mm_end = end - 3;
while (s < mm_end) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq %1, %%mm1 \n\t"
"movq %1, %%mm2 \n\t"
"pand %2, %%mm0 \n\t"
"pand %3, %%mm1 \n\t"
"pand %4, %%mm2 \n\t"
"psllq $3, %%mm0 \n\t"
"psrlq $3, %%mm1 \n\t"
"psrlq $8, %%mm2 \n\t"
PACK_RGB32
:"=m"(*d)
:"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r)
:"memory");
d += 16;
s += 4;
}
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
while (s < end) {
register uint16_t bgr;
bgr = *s++;
*d++ = (bgr&0x1F)<<3;
*d++ = (bgr&0x7E0)>>3;
*d++ = (bgr&0xF800)>>8;
*d++ = 255;
}
}
static inline void RENAME(shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size)
{
x86_reg idx = 15 - src_size;
const uint8_t *s = src-idx;
uint8_t *d = dst-idx;
__asm__ volatile(
"test %0, %0 \n\t"
"jns 2f \n\t"
PREFETCH" (%1, %0) \n\t"
"movq %3, %%mm7 \n\t"
"pxor %4, %%mm7 \n\t"
"movq %%mm7, %%mm6 \n\t"
"pxor %5, %%mm7 \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1, %0) \n\t"
"movq (%1, %0), %%mm0 \n\t"
"movq 8(%1, %0), %%mm1 \n\t"
# if COMPILE_TEMPLATE_MMX2
"pshufw $177, %%mm0, %%mm3 \n\t"
"pshufw $177, %%mm1, %%mm5 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm6, %%mm3 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm6, %%mm5 \n\t"
"por %%mm3, %%mm0 \n\t"
"por %%mm5, %%mm1 \n\t"
# else
"movq %%mm0, %%mm2 \n\t"
"movq %%mm1, %%mm4 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm6, %%mm2 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm6, %%mm4 \n\t"
"movq %%mm2, %%mm3 \n\t"
"movq %%mm4, %%mm5 \n\t"
"pslld $16, %%mm2 \n\t"
"psrld $16, %%mm3 \n\t"
"pslld $16, %%mm4 \n\t"
"psrld $16, %%mm5 \n\t"
"por %%mm2, %%mm0 \n\t"
"por %%mm4, %%mm1 \n\t"
"por %%mm3, %%mm0 \n\t"
"por %%mm5, %%mm1 \n\t"
# endif
MOVNTQ" %%mm0, (%2, %0) \n\t"
MOVNTQ" %%mm1, 8(%2, %0) \n\t"
"add $16, %0 \n\t"
"js 1b \n\t"
SFENCE" \n\t"
EMMS" \n\t"
"2: \n\t"
: "+&r"(idx)
: "r" (s), "r" (d), "m" (mask32b), "m" (mask32r), "m" (mmx_one)
: "memory");
for (; idx<15; idx+=4) {
register int v = *(const uint32_t *)&s[idx], g = v & 0xff00ff00;
v &= 0xff00ff;
*(uint32_t *)&d[idx] = (v>>16) + g + (v<<16);
}
}
static inline void RENAME(rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
{
unsigned i;
x86_reg mmx_size= 23 - src_size;
__asm__ volatile (
"test %%"REG_a", %%"REG_a" \n\t"
"jns 2f \n\t"
"movq "MANGLE(mask24r)", %%mm5 \n\t"
"movq "MANGLE(mask24g)", %%mm6 \n\t"
"movq "MANGLE(mask24b)", %%mm7 \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a") \n\t"
"movq (%1, %%"REG_a"), %%mm0 \n\t" // BGR BGR BG
"movq (%1, %%"REG_a"), %%mm1 \n\t" // BGR BGR BG
"movq 2(%1, %%"REG_a"), %%mm2 \n\t" // R BGR BGR B
"psllq $16, %%mm0 \n\t" // 00 BGR BGR
"pand %%mm5, %%mm0 \n\t"
"pand %%mm6, %%mm1 \n\t"
"pand %%mm7, %%mm2 \n\t"
"por %%mm0, %%mm1 \n\t"
"por %%mm2, %%mm1 \n\t"
"movq 6(%1, %%"REG_a"), %%mm0 \n\t" // BGR BGR BG
MOVNTQ" %%mm1, (%2, %%"REG_a") \n\t" // RGB RGB RG
"movq 8(%1, %%"REG_a"), %%mm1 \n\t" // R BGR BGR B
"movq 10(%1, %%"REG_a"), %%mm2 \n\t" // GR BGR BGR
"pand %%mm7, %%mm0 \n\t"
"pand %%mm5, %%mm1 \n\t"
"pand %%mm6, %%mm2 \n\t"
"por %%mm0, %%mm1 \n\t"
"por %%mm2, %%mm1 \n\t"
"movq 14(%1, %%"REG_a"), %%mm0 \n\t" // R BGR BGR B
MOVNTQ" %%mm1, 8(%2, %%"REG_a") \n\t" // B RGB RGB R
"movq 16(%1, %%"REG_a"), %%mm1 \n\t" // GR BGR BGR
"movq 18(%1, %%"REG_a"), %%mm2 \n\t" // BGR BGR BG
"pand %%mm6, %%mm0 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm5, %%mm2 \n\t"
"por %%mm0, %%mm1 \n\t"
"por %%mm2, %%mm1 \n\t"
MOVNTQ" %%mm1, 16(%2, %%"REG_a") \n\t"
"add $24, %%"REG_a" \n\t"
" js 1b \n\t"
"2: \n\t"
: "+a" (mmx_size)
: "r" (src-mmx_size), "r"(dst-mmx_size)
);
__asm__ volatile(SFENCE:::"memory");
__asm__ volatile(EMMS:::"memory");
if (mmx_size==23) return; //finished, was multiple of 8
src+= src_size;
dst+= src_size;
src_size= 23-mmx_size;
src-= src_size;
dst-= src_size;
for (i=0; i<src_size; i+=3) {
register uint8_t x;
x = src[i + 2];
dst[i + 1] = src[i + 1];
dst[i + 2] = src[i + 0];
dst[i + 0] = x;
}
}
static inline void RENAME(yuvPlanartoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride, int vertLumPerChroma)
{
int y;
const x86_reg chromWidth= width>>1;
for (y=0; y<height; y++) {
//FIXME handle 2 lines at once (fewer prefetches, reuse some chroma, but very likely memory-limited anyway)
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a", 2) \n\t"
PREFETCH" 32(%2, %%"REG_a") \n\t"
PREFETCH" 32(%3, %%"REG_a") \n\t"
"movq (%2, %%"REG_a"), %%mm0 \n\t" // U(0)
"movq %%mm0, %%mm2 \n\t" // U(0)
"movq (%3, %%"REG_a"), %%mm1 \n\t" // V(0)
"punpcklbw %%mm1, %%mm0 \n\t" // UVUV UVUV(0)
"punpckhbw %%mm1, %%mm2 \n\t" // UVUV UVUV(8)
"movq (%1, %%"REG_a",2), %%mm3 \n\t" // Y(0)
"movq 8(%1, %%"REG_a",2), %%mm5 \n\t" // Y(8)
"movq %%mm3, %%mm4 \n\t" // Y(0)
"movq %%mm5, %%mm6 \n\t" // Y(8)
"punpcklbw %%mm0, %%mm3 \n\t" // YUYV YUYV(0)
"punpckhbw %%mm0, %%mm4 \n\t" // YUYV YUYV(4)
"punpcklbw %%mm2, %%mm5 \n\t" // YUYV YUYV(8)
"punpckhbw %%mm2, %%mm6 \n\t" // YUYV YUYV(12)
MOVNTQ" %%mm3, (%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm4, 8(%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm5, 16(%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm6, 24(%0, %%"REG_a", 4) \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
: "%"REG_a
);
if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
__asm__(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
/**
* Height should be a multiple of 2 and width should be a multiple of 16.
* (If this is a problem for anyone then tell me, and I will fix it.)
*/
static inline void RENAME(yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride)
{
//FIXME interpolate chroma
RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);
}
static inline void RENAME(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride, int vertLumPerChroma)
{
int y;
const x86_reg chromWidth= width>>1;
for (y=0; y<height; y++) {
//FIXME handle 2 lines at once (fewer prefetches, reuse some chroma, but very likely memory-limited anyway)
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a", 2) \n\t"
PREFETCH" 32(%2, %%"REG_a") \n\t"
PREFETCH" 32(%3, %%"REG_a") \n\t"
"movq (%2, %%"REG_a"), %%mm0 \n\t" // U(0)
"movq %%mm0, %%mm2 \n\t" // U(0)
"movq (%3, %%"REG_a"), %%mm1 \n\t" // V(0)
"punpcklbw %%mm1, %%mm0 \n\t" // UVUV UVUV(0)
"punpckhbw %%mm1, %%mm2 \n\t" // UVUV UVUV(8)
"movq (%1, %%"REG_a",2), %%mm3 \n\t" // Y(0)
"movq 8(%1, %%"REG_a",2), %%mm5 \n\t" // Y(8)
"movq %%mm0, %%mm4 \n\t" // Y(0)
"movq %%mm2, %%mm6 \n\t" // Y(8)
"punpcklbw %%mm3, %%mm0 \n\t" // YUYV YUYV(0)
"punpckhbw %%mm3, %%mm4 \n\t" // YUYV YUYV(4)
"punpcklbw %%mm5, %%mm2 \n\t" // YUYV YUYV(8)
"punpckhbw %%mm5, %%mm6 \n\t" // YUYV YUYV(12)
MOVNTQ" %%mm0, (%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm4, 8(%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm2, 16(%0, %%"REG_a", 4) \n\t"
MOVNTQ" %%mm6, 24(%0, %%"REG_a", 4) \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
: "%"REG_a
);
if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
__asm__(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
/**
* Height should be a multiple of 2 and width should be a multiple of 16
* (If this is a problem for anyone then tell me, and I will fix it.)
*/
static inline void RENAME(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride)
{
//FIXME interpolate chroma
RENAME(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);
}
/**
* Width should be a multiple of 16.
*/
static inline void RENAME(yuv422ptouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride)
{
RENAME(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 1);
}
/**
* Width should be a multiple of 16.
*/
static inline void RENAME(yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
int width, int height,
int lumStride, int chromStride, int dstStride)
{
RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 1);
}
/**
* Height should be a multiple of 2 and width should be a multiple of 16.
* (If this is a problem for anyone then tell me, and I will fix it.)
*/
static inline void RENAME(yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const x86_reg chromWidth= width>>1;
for (y=0; y<height; y+=2) {
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t" // FF,00,FF,00...
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_a", 4) \n\t"
"movq (%0, %%"REG_a", 4), %%mm0 \n\t" // YUYV YUYV(0)
"movq 8(%0, %%"REG_a", 4), %%mm1 \n\t" // YUYV YUYV(4)
"movq %%mm0, %%mm2 \n\t" // YUYV YUYV(0)
"movq %%mm1, %%mm3 \n\t" // YUYV YUYV(4)
"psrlw $8, %%mm0 \n\t" // U0V0 U0V0(0)
"psrlw $8, %%mm1 \n\t" // U0V0 U0V0(4)
"pand %%mm7, %%mm2 \n\t" // Y0Y0 Y0Y0(0)
"pand %%mm7, %%mm3 \n\t" // Y0Y0 Y0Y0(4)
"packuswb %%mm1, %%mm0 \n\t" // UVUV UVUV(0)
"packuswb %%mm3, %%mm2 \n\t" // YYYY YYYY(0)
MOVNTQ" %%mm2, (%1, %%"REG_a", 2) \n\t"
"movq 16(%0, %%"REG_a", 4), %%mm1 \n\t" // YUYV YUYV(8)
"movq 24(%0, %%"REG_a", 4), %%mm2 \n\t" // YUYV YUYV(12)
"movq %%mm1, %%mm3 \n\t" // YUYV YUYV(8)
"movq %%mm2, %%mm4 \n\t" // YUYV YUYV(12)
"psrlw $8, %%mm1 \n\t" // U0V0 U0V0(8)
"psrlw $8, %%mm2 \n\t" // U0V0 U0V0(12)
"pand %%mm7, %%mm3 \n\t" // Y0Y0 Y0Y0(8)
"pand %%mm7, %%mm4 \n\t" // Y0Y0 Y0Y0(12)
"packuswb %%mm2, %%mm1 \n\t" // UVUV UVUV(8)
"packuswb %%mm4, %%mm3 \n\t" // YYYY YYYY(8)
MOVNTQ" %%mm3, 8(%1, %%"REG_a", 2) \n\t"
"movq %%mm0, %%mm2 \n\t" // UVUV UVUV(0)
"movq %%mm1, %%mm3 \n\t" // UVUV UVUV(8)
"psrlw $8, %%mm0 \n\t" // V0V0 V0V0(0)
"psrlw $8, %%mm1 \n\t" // V0V0 V0V0(8)
"pand %%mm7, %%mm2 \n\t" // U0U0 U0U0(0)
"pand %%mm7, %%mm3 \n\t" // U0U0 U0U0(8)
"packuswb %%mm1, %%mm0 \n\t" // VVVV VVVV(0)
"packuswb %%mm3, %%mm2 \n\t" // UUUU UUUU(0)
MOVNTQ" %%mm0, (%3, %%"REG_a") \n\t"
MOVNTQ" %%mm2, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
: "memory", "%"REG_a
);
ydst += lumStride;
src += srcStride;
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_a", 4) \n\t"
"movq (%0, %%"REG_a", 4), %%mm0 \n\t" // YUYV YUYV(0)
"movq 8(%0, %%"REG_a", 4), %%mm1 \n\t" // YUYV YUYV(4)
"movq 16(%0, %%"REG_a", 4), %%mm2 \n\t" // YUYV YUYV(8)
"movq 24(%0, %%"REG_a", 4), %%mm3 \n\t" // YUYV YUYV(12)
"pand %%mm7, %%mm0 \n\t" // Y0Y0 Y0Y0(0)
"pand %%mm7, %%mm1 \n\t" // Y0Y0 Y0Y0(4)
"pand %%mm7, %%mm2 \n\t" // Y0Y0 Y0Y0(8)
"pand %%mm7, %%mm3 \n\t" // Y0Y0 Y0Y0(12)
"packuswb %%mm1, %%mm0 \n\t" // YYYY YYYY(0)
"packuswb %%mm3, %%mm2 \n\t" // YYYY YYYY(8)
MOVNTQ" %%mm0, (%1, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm2, 8(%1, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
: "memory", "%"REG_a
);
udst += chromStride;
vdst += chromStride;
ydst += lumStride;
src += srcStride;
}
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
#if COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW
static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)
{
int x,y;
dst[0]= src[0];
// first line
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
dst+= dstStride;
for (y=1; y<srcHeight; y++) {
const x86_reg mmxSize= srcWidth&~15;
__asm__ volatile(
"mov %4, %%"REG_a" \n\t"
"movq "MANGLE(mmx_ff)", %%mm0 \n\t"
"movq (%0, %%"REG_a"), %%mm4 \n\t"
"movq %%mm4, %%mm2 \n\t"
"psllq $8, %%mm4 \n\t"
"pand %%mm0, %%mm2 \n\t"
"por %%mm2, %%mm4 \n\t"
"movq (%1, %%"REG_a"), %%mm5 \n\t"
"movq %%mm5, %%mm3 \n\t"
"psllq $8, %%mm5 \n\t"
"pand %%mm0, %%mm3 \n\t"
"por %%mm3, %%mm5 \n\t"
"1: \n\t"
"movq (%0, %%"REG_a"), %%mm0 \n\t"
"movq (%1, %%"REG_a"), %%mm1 \n\t"
"movq 1(%0, %%"REG_a"), %%mm2 \n\t"
"movq 1(%1, %%"REG_a"), %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm4, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm5 \n\t"
"punpckhbw %%mm3, %%mm7 \n\t"
"punpcklbw %%mm2, %%mm4 \n\t"
"punpckhbw %%mm2, %%mm6 \n\t"
MOVNTQ" %%mm5, (%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm7, 8(%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm4, (%3, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm6, 8(%3, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"movq -1(%0, %%"REG_a"), %%mm4 \n\t"
"movq -1(%1, %%"REG_a"), %%mm5 \n\t"
" js 1b \n\t"
:: "r" (src + mmxSize ), "r" (src + srcStride + mmxSize ),
"r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),
"g" (-mmxSize)
: "%"REG_a
);
for (x=mmxSize-1; x<srcWidth-1; x++) {
dst[2*x +1]= (3*src[x+0] + src[x+srcStride+1])>>2;
dst[2*x+dstStride+2]= ( src[x+0] + 3*src[x+srcStride+1])>>2;
dst[2*x+dstStride+1]= ( src[x+1] + 3*src[x+srcStride ])>>2;
dst[2*x +2]= (3*src[x+1] + src[x+srcStride ])>>2;
}
dst[srcWidth*2 -1 ]= (3*src[srcWidth-1] + src[srcWidth-1 + srcStride])>>2;
dst[srcWidth*2 -1 + dstStride]= ( src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
dst+=dstStride*2;
src+=srcStride;
}
// last line
dst[0]= src[0];
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
#endif /* COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW */
#if !COMPILE_TEMPLATE_AMD3DNOW
/**
* Height should be a multiple of 2 and width should be a multiple of 16.
* (If this is a problem for anyone then tell me, and I will fix it.)
* Chrominance data is only taken from every second line, others are ignored.
* FIXME: Write HQ version.
*/
static inline void RENAME(uyvytoyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const x86_reg chromWidth= width>>1;
for (y=0; y<height; y+=2) {
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t" // FF,00,FF,00...
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_a", 4) \n\t"
"movq (%0, %%"REG_a", 4), %%mm0 \n\t" // UYVY UYVY(0)
"movq 8(%0, %%"REG_a", 4), %%mm1 \n\t" // UYVY UYVY(4)
"movq %%mm0, %%mm2 \n\t" // UYVY UYVY(0)
"movq %%mm1, %%mm3 \n\t" // UYVY UYVY(4)
"pand %%mm7, %%mm0 \n\t" // U0V0 U0V0(0)
"pand %%mm7, %%mm1 \n\t" // U0V0 U0V0(4)
"psrlw $8, %%mm2 \n\t" // Y0Y0 Y0Y0(0)
"psrlw $8, %%mm3 \n\t" // Y0Y0 Y0Y0(4)
"packuswb %%mm1, %%mm0 \n\t" // UVUV UVUV(0)
"packuswb %%mm3, %%mm2 \n\t" // YYYY YYYY(0)
MOVNTQ" %%mm2, (%1, %%"REG_a", 2) \n\t"
"movq 16(%0, %%"REG_a", 4), %%mm1 \n\t" // UYVY UYVY(8)
"movq 24(%0, %%"REG_a", 4), %%mm2 \n\t" // UYVY UYVY(12)
"movq %%mm1, %%mm3 \n\t" // UYVY UYVY(8)
"movq %%mm2, %%mm4 \n\t" // UYVY UYVY(12)
"pand %%mm7, %%mm1 \n\t" // U0V0 U0V0(8)
"pand %%mm7, %%mm2 \n\t" // U0V0 U0V0(12)
"psrlw $8, %%mm3 \n\t" // Y0Y0 Y0Y0(8)
"psrlw $8, %%mm4 \n\t" // Y0Y0 Y0Y0(12)
"packuswb %%mm2, %%mm1 \n\t" // UVUV UVUV(8)
"packuswb %%mm4, %%mm3 \n\t" // YYYY YYYY(8)
MOVNTQ" %%mm3, 8(%1, %%"REG_a", 2) \n\t"
"movq %%mm0, %%mm2 \n\t" // UVUV UVUV(0)
"movq %%mm1, %%mm3 \n\t" // UVUV UVUV(8)
"psrlw $8, %%mm0 \n\t" // V0V0 V0V0(0)
"psrlw $8, %%mm1 \n\t" // V0V0 V0V0(8)
"pand %%mm7, %%mm2 \n\t" // U0U0 U0U0(0)
"pand %%mm7, %%mm3 \n\t" // U0U0 U0U0(8)
"packuswb %%mm1, %%mm0 \n\t" // VVVV VVVV(0)
"packuswb %%mm3, %%mm2 \n\t" // UUUU UUUU(0)
MOVNTQ" %%mm0, (%3, %%"REG_a") \n\t"
MOVNTQ" %%mm2, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
: "memory", "%"REG_a
);
ydst += lumStride;
src += srcStride;
__asm__ volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_a", 4) \n\t"
"movq (%0, %%"REG_a", 4), %%mm0 \n\t" // YUYV YUYV(0)
"movq 8(%0, %%"REG_a", 4), %%mm1 \n\t" // YUYV YUYV(4)
"movq 16(%0, %%"REG_a", 4), %%mm2 \n\t" // YUYV YUYV(8)
"movq 24(%0, %%"REG_a", 4), %%mm3 \n\t" // YUYV YUYV(12)
"psrlw $8, %%mm0 \n\t" // Y0Y0 Y0Y0(0)
"psrlw $8, %%mm1 \n\t" // Y0Y0 Y0Y0(4)
"psrlw $8, %%mm2 \n\t" // Y0Y0 Y0Y0(8)
"psrlw $8, %%mm3 \n\t" // Y0Y0 Y0Y0(12)
"packuswb %%mm1, %%mm0 \n\t" // YYYY YYYY(0)
"packuswb %%mm3, %%mm2 \n\t" // YYYY YYYY(8)
MOVNTQ" %%mm0, (%1, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm2, 8(%1, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
: "memory", "%"REG_a
);
udst += chromStride;
vdst += chromStride;
ydst += lumStride;
src += srcStride;
}
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
/**
* Height should be a multiple of 2 and width should be a multiple of 2.
* (If this is a problem for anyone then tell me, and I will fix it.)
* Chrominance data is only taken from every second line,
* others are ignored in the C version.
* FIXME: Write HQ version.
*/
static inline void RENAME(rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const x86_reg chromWidth= width>>1;
for (y=0; y<height-2; y+=2) {
int i;
for (i=0; i<2; i++) {
__asm__ volatile(
"mov %2, %%"REG_a" \n\t"
"movq "MANGLE(ff_bgr2YCoeff)", %%mm6 \n\t"
"movq "MANGLE(ff_w1111)", %%mm5 \n\t"
"pxor %%mm7, %%mm7 \n\t"
"lea (%%"REG_a", %%"REG_a", 2), %%"REG_d" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_d") \n\t"
"movd (%0, %%"REG_d"), %%mm0 \n\t"
"movd 3(%0, %%"REG_d"), %%mm1 \n\t"
"punpcklbw %%mm7, %%mm0 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"movd 6(%0, %%"REG_d"), %%mm2 \n\t"
"movd 9(%0, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"pmaddwd %%mm6, %%mm0 \n\t"
"pmaddwd %%mm6, %%mm1 \n\t"
"pmaddwd %%mm6, %%mm2 \n\t"
"pmaddwd %%mm6, %%mm3 \n\t"
#ifndef FAST_BGR2YV12
"psrad $8, %%mm0 \n\t"
"psrad $8, %%mm1 \n\t"
"psrad $8, %%mm2 \n\t"
"psrad $8, %%mm3 \n\t"
#endif
"packssdw %%mm1, %%mm0 \n\t"
"packssdw %%mm3, %%mm2 \n\t"
"pmaddwd %%mm5, %%mm0 \n\t"
"pmaddwd %%mm5, %%mm2 \n\t"
"packssdw %%mm2, %%mm0 \n\t"
"psraw $7, %%mm0 \n\t"
"movd 12(%0, %%"REG_d"), %%mm4 \n\t"
"movd 15(%0, %%"REG_d"), %%mm1 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"movd 18(%0, %%"REG_d"), %%mm2 \n\t"
"movd 21(%0, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"pmaddwd %%mm6, %%mm4 \n\t"
"pmaddwd %%mm6, %%mm1 \n\t"
"pmaddwd %%mm6, %%mm2 \n\t"
"pmaddwd %%mm6, %%mm3 \n\t"
#ifndef FAST_BGR2YV12
"psrad $8, %%mm4 \n\t"
"psrad $8, %%mm1 \n\t"
"psrad $8, %%mm2 \n\t"
"psrad $8, %%mm3 \n\t"
#endif
"packssdw %%mm1, %%mm4 \n\t"
"packssdw %%mm3, %%mm2 \n\t"
"pmaddwd %%mm5, %%mm4 \n\t"
"pmaddwd %%mm5, %%mm2 \n\t"
"add $24, %%"REG_d" \n\t"
"packssdw %%mm2, %%mm4 \n\t"
"psraw $7, %%mm4 \n\t"
"packuswb %%mm4, %%mm0 \n\t"
"paddusb "MANGLE(ff_bgr2YOffset)", %%mm0 \n\t"
MOVNTQ" %%mm0, (%1, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "r" (src+width*3), "r" (ydst+width), "g" ((x86_reg)-width)
: "%"REG_a, "%"REG_d
);
ydst += lumStride;
src += srcStride;
}
src -= srcStride*2;
__asm__ volatile(
"mov %4, %%"REG_a" \n\t"
"movq "MANGLE(ff_w1111)", %%mm5 \n\t"
"movq "MANGLE(ff_bgr2UCoeff)", %%mm6 \n\t"
"pxor %%mm7, %%mm7 \n\t"
"lea (%%"REG_a", %%"REG_a", 2), %%"REG_d" \n\t"
"add %%"REG_d", %%"REG_d" \n\t"
".p2align 4 \n\t"
"1: \n\t"
PREFETCH" 64(%0, %%"REG_d") \n\t"
PREFETCH" 64(%1, %%"REG_d") \n\t"
#if COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW
"movq (%0, %%"REG_d"), %%mm0 \n\t"
"movq (%1, %%"REG_d"), %%mm1 \n\t"
"movq 6(%0, %%"REG_d"), %%mm2 \n\t"
"movq 6(%1, %%"REG_d"), %%mm3 \n\t"
PAVGB" %%mm1, %%mm0 \n\t"
PAVGB" %%mm3, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlq $24, %%mm0 \n\t"
"psrlq $24, %%mm2 \n\t"
PAVGB" %%mm1, %%mm0 \n\t"
PAVGB" %%mm3, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm0 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
#else
"movd (%0, %%"REG_d"), %%mm0 \n\t"
"movd (%1, %%"REG_d"), %%mm1 \n\t"
"movd 3(%0, %%"REG_d"), %%mm2 \n\t"
"movd 3(%1, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm0 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"paddw %%mm1, %%mm0 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm2, %%mm0 \n\t"
"movd 6(%0, %%"REG_d"), %%mm4 \n\t"
"movd 6(%1, %%"REG_d"), %%mm1 \n\t"
"movd 9(%0, %%"REG_d"), %%mm2 \n\t"
"movd 9(%1, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"paddw %%mm1, %%mm4 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm4, %%mm2 \n\t"
"psrlw $2, %%mm0 \n\t"
"psrlw $2, %%mm2 \n\t"
#endif
"movq "MANGLE(ff_bgr2VCoeff)", %%mm1 \n\t"
"movq "MANGLE(ff_bgr2VCoeff)", %%mm3 \n\t"
"pmaddwd %%mm0, %%mm1 \n\t"
"pmaddwd %%mm2, %%mm3 \n\t"
"pmaddwd %%mm6, %%mm0 \n\t"
"pmaddwd %%mm6, %%mm2 \n\t"
#ifndef FAST_BGR2YV12
"psrad $8, %%mm0 \n\t"
"psrad $8, %%mm1 \n\t"
"psrad $8, %%mm2 \n\t"
"psrad $8, %%mm3 \n\t"
#endif
"packssdw %%mm2, %%mm0 \n\t"
"packssdw %%mm3, %%mm1 \n\t"
"pmaddwd %%mm5, %%mm0 \n\t"
"pmaddwd %%mm5, %%mm1 \n\t"
"packssdw %%mm1, %%mm0 \n\t" // V1 V0 U1 U0
"psraw $7, %%mm0 \n\t"
#if COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW
"movq 12(%0, %%"REG_d"), %%mm4 \n\t"
"movq 12(%1, %%"REG_d"), %%mm1 \n\t"
"movq 18(%0, %%"REG_d"), %%mm2 \n\t"
"movq 18(%1, %%"REG_d"), %%mm3 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm3, %%mm2 \n\t"
"movq %%mm4, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlq $24, %%mm4 \n\t"
"psrlq $24, %%mm2 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm3, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
#else
"movd 12(%0, %%"REG_d"), %%mm4 \n\t"
"movd 12(%1, %%"REG_d"), %%mm1 \n\t"
"movd 15(%0, %%"REG_d"), %%mm2 \n\t"
"movd 15(%1, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"paddw %%mm1, %%mm4 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm2, %%mm4 \n\t"
"movd 18(%0, %%"REG_d"), %%mm5 \n\t"
"movd 18(%1, %%"REG_d"), %%mm1 \n\t"
"movd 21(%0, %%"REG_d"), %%mm2 \n\t"
"movd 21(%1, %%"REG_d"), %%mm3 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm1 \n\t"
"punpcklbw %%mm7, %%mm2 \n\t"
"punpcklbw %%mm7, %%mm3 \n\t"
"paddw %%mm1, %%mm5 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm5, %%mm2 \n\t"
"movq "MANGLE(ff_w1111)", %%mm5 \n\t"
"psrlw $2, %%mm4 \n\t"
"psrlw $2, %%mm2 \n\t"
#endif
"movq "MANGLE(ff_bgr2VCoeff)", %%mm1 \n\t"
"movq "MANGLE(ff_bgr2VCoeff)", %%mm3 \n\t"
"pmaddwd %%mm4, %%mm1 \n\t"
"pmaddwd %%mm2, %%mm3 \n\t"
"pmaddwd %%mm6, %%mm4 \n\t"
"pmaddwd %%mm6, %%mm2 \n\t"
#ifndef FAST_BGR2YV12
"psrad $8, %%mm4 \n\t"
"psrad $8, %%mm1 \n\t"
"psrad $8, %%mm2 \n\t"
"psrad $8, %%mm3 \n\t"
#endif
"packssdw %%mm2, %%mm4 \n\t"
"packssdw %%mm3, %%mm1 \n\t"
"pmaddwd %%mm5, %%mm4 \n\t"
"pmaddwd %%mm5, %%mm1 \n\t"
"add $24, %%"REG_d" \n\t"
"packssdw %%mm1, %%mm4 \n\t" // V3 V2 U3 U2
"psraw $7, %%mm4 \n\t"
"movq %%mm0, %%mm1 \n\t"
"punpckldq %%mm4, %%mm0 \n\t"
"punpckhdq %%mm4, %%mm1 \n\t"
"packsswb %%mm1, %%mm0 \n\t"
"paddb "MANGLE(ff_bgr2UVOffset)", %%mm0 \n\t"
"movd %%mm0, (%2, %%"REG_a") \n\t"
"punpckhdq %%mm0, %%mm0 \n\t"
"movd %%mm0, (%3, %%"REG_a") \n\t"
"add $4, %%"REG_a" \n\t"
" js 1b \n\t"
: : "r" (src+chromWidth*6), "r" (src+srcStride+chromWidth*6), "r" (udst+chromWidth), "r" (vdst+chromWidth), "g" (-chromWidth)
: "%"REG_a, "%"REG_d
);
udst += chromStride;
vdst += chromStride;
src += srcStride*2;
}
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
rgb24toyv12_c(src, ydst, udst, vdst, width, height-y, lumStride, chromStride, srcStride);
}
#endif /* !COMPILE_TEMPLATE_SSE2 */
#if !COMPILE_TEMPLATE_AMD3DNOW
static void RENAME(interleaveBytes)(const uint8_t *src1, const uint8_t *src2, uint8_t *dest,
int width, int height, int src1Stride,
int src2Stride, int dstStride)
{
int h;
for (h=0; h < height; h++) {
int w;
if (width >= 16)
#if COMPILE_TEMPLATE_SSE2
__asm__(
"xor %%"REG_a", %%"REG_a" \n\t"
"1: \n\t"
PREFETCH" 64(%1, %%"REG_a") \n\t"
PREFETCH" 64(%2, %%"REG_a") \n\t"
"movdqa (%1, %%"REG_a"), %%xmm0 \n\t"
"movdqa (%1, %%"REG_a"), %%xmm1 \n\t"
"movdqa (%2, %%"REG_a"), %%xmm2 \n\t"
"punpcklbw %%xmm2, %%xmm0 \n\t"
"punpckhbw %%xmm2, %%xmm1 \n\t"
"movntdq %%xmm0, (%0, %%"REG_a", 2) \n\t"
"movntdq %%xmm1, 16(%0, %%"REG_a", 2) \n\t"
"add $16, %%"REG_a" \n\t"
"cmp %3, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dest), "r"(src1), "r"(src2), "r" ((x86_reg)width-15)
: "memory", "%"REG_a""
);
#else
__asm__(
"xor %%"REG_a", %%"REG_a" \n\t"
"1: \n\t"
PREFETCH" 64(%1, %%"REG_a") \n\t"
PREFETCH" 64(%2, %%"REG_a") \n\t"
"movq (%1, %%"REG_a"), %%mm0 \n\t"
"movq 8(%1, %%"REG_a"), %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"movq (%2, %%"REG_a"), %%mm4 \n\t"
"movq 8(%2, %%"REG_a"), %%mm5 \n\t"
"punpcklbw %%mm4, %%mm0 \n\t"
"punpckhbw %%mm4, %%mm1 \n\t"
"punpcklbw %%mm5, %%mm2 \n\t"
"punpckhbw %%mm5, %%mm3 \n\t"
MOVNTQ" %%mm0, (%0, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm1, 8(%0, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm2, 16(%0, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm3, 24(%0, %%"REG_a", 2) \n\t"
"add $16, %%"REG_a" \n\t"
"cmp %3, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dest), "r"(src1), "r"(src2), "r" ((x86_reg)width-15)
: "memory", "%"REG_a
);
#endif
for (w= (width&(~15)); w < width; w++) {
dest[2*w+0] = src1[w];
dest[2*w+1] = src2[w];
}
dest += dstStride;
src1 += src1Stride;
src2 += src2Stride;
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
#if !COMPILE_TEMPLATE_SSE2
#if !COMPILE_TEMPLATE_AMD3DNOW
static inline void RENAME(vu9_to_vu12)(const uint8_t *src1, const uint8_t *src2,
uint8_t *dst1, uint8_t *dst2,
int width, int height,
int srcStride1, int srcStride2,
int dstStride1, int dstStride2)
{
x86_reg y;
int x,w,h;
w=width/2; h=height/2;
__asm__ volatile(
PREFETCH" %0 \n\t"
PREFETCH" %1 \n\t"
::"m"(*(src1+srcStride1)),"m"(*(src2+srcStride2)):"memory");
for (y=0;y<h;y++) {
const uint8_t* s1=src1+srcStride1*(y>>1);
uint8_t* d=dst1+dstStride1*y;
x=0;
for (;x<w-31;x+=32) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq 8%1, %%mm2 \n\t"
"movq 16%1, %%mm4 \n\t"
"movq 24%1, %%mm6 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"movq %%mm4, %%mm5 \n\t"
"movq %%mm6, %%mm7 \n\t"
"punpcklbw %%mm0, %%mm0 \n\t"
"punpckhbw %%mm1, %%mm1 \n\t"
"punpcklbw %%mm2, %%mm2 \n\t"
"punpckhbw %%mm3, %%mm3 \n\t"
"punpcklbw %%mm4, %%mm4 \n\t"
"punpckhbw %%mm5, %%mm5 \n\t"
"punpcklbw %%mm6, %%mm6 \n\t"
"punpckhbw %%mm7, %%mm7 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
MOVNTQ" %%mm1, 8%0 \n\t"
MOVNTQ" %%mm2, 16%0 \n\t"
MOVNTQ" %%mm3, 24%0 \n\t"
MOVNTQ" %%mm4, 32%0 \n\t"
MOVNTQ" %%mm5, 40%0 \n\t"
MOVNTQ" %%mm6, 48%0 \n\t"
MOVNTQ" %%mm7, 56%0"
:"=m"(d[2*x])
:"m"(s1[x])
:"memory");
}
for (;x<w;x++) d[2*x]=d[2*x+1]=s1[x];
}
for (y=0;y<h;y++) {
const uint8_t* s2=src2+srcStride2*(y>>1);
uint8_t* d=dst2+dstStride2*y;
x=0;
for (;x<w-31;x+=32) {
__asm__ volatile(
PREFETCH" 32%1 \n\t"
"movq %1, %%mm0 \n\t"
"movq 8%1, %%mm2 \n\t"
"movq 16%1, %%mm4 \n\t"
"movq 24%1, %%mm6 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"movq %%mm4, %%mm5 \n\t"
"movq %%mm6, %%mm7 \n\t"
"punpcklbw %%mm0, %%mm0 \n\t"
"punpckhbw %%mm1, %%mm1 \n\t"
"punpcklbw %%mm2, %%mm2 \n\t"
"punpckhbw %%mm3, %%mm3 \n\t"
"punpcklbw %%mm4, %%mm4 \n\t"
"punpckhbw %%mm5, %%mm5 \n\t"
"punpcklbw %%mm6, %%mm6 \n\t"
"punpckhbw %%mm7, %%mm7 \n\t"
MOVNTQ" %%mm0, %0 \n\t"
MOVNTQ" %%mm1, 8%0 \n\t"
MOVNTQ" %%mm2, 16%0 \n\t"
MOVNTQ" %%mm3, 24%0 \n\t"
MOVNTQ" %%mm4, 32%0 \n\t"
MOVNTQ" %%mm5, 40%0 \n\t"
MOVNTQ" %%mm6, 48%0 \n\t"
MOVNTQ" %%mm7, 56%0"
:"=m"(d[2*x])
:"m"(s2[x])
:"memory");
}
for (;x<w;x++) d[2*x]=d[2*x+1]=s2[x];
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
static inline void RENAME(yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
uint8_t *dst,
int width, int height,
int srcStride1, int srcStride2,
int srcStride3, int dstStride)
{
x86_reg x;
int y,w,h;
w=width/2; h=height;
for (y=0;y<h;y++) {
const uint8_t* yp=src1+srcStride1*y;
const uint8_t* up=src2+srcStride2*(y>>2);
const uint8_t* vp=src3+srcStride3*(y>>2);
uint8_t* d=dst+dstStride*y;
x=0;
for (;x<w-7;x+=8) {
__asm__ volatile(
PREFETCH" 32(%1, %0) \n\t"
PREFETCH" 32(%2, %0) \n\t"
PREFETCH" 32(%3, %0) \n\t"
"movq (%1, %0, 4), %%mm0 \n\t" /* Y0Y1Y2Y3Y4Y5Y6Y7 */
"movq (%2, %0), %%mm1 \n\t" /* U0U1U2U3U4U5U6U7 */
"movq (%3, %0), %%mm2 \n\t" /* V0V1V2V3V4V5V6V7 */
"movq %%mm0, %%mm3 \n\t" /* Y0Y1Y2Y3Y4Y5Y6Y7 */
"movq %%mm1, %%mm4 \n\t" /* U0U1U2U3U4U5U6U7 */
"movq %%mm2, %%mm5 \n\t" /* V0V1V2V3V4V5V6V7 */
"punpcklbw %%mm1, %%mm1 \n\t" /* U0U0 U1U1 U2U2 U3U3 */
"punpcklbw %%mm2, %%mm2 \n\t" /* V0V0 V1V1 V2V2 V3V3 */
"punpckhbw %%mm4, %%mm4 \n\t" /* U4U4 U5U5 U6U6 U7U7 */
"punpckhbw %%mm5, %%mm5 \n\t" /* V4V4 V5V5 V6V6 V7V7 */
"movq %%mm1, %%mm6 \n\t"
"punpcklbw %%mm2, %%mm1 \n\t" /* U0V0 U0V0 U1V1 U1V1*/
"punpcklbw %%mm1, %%mm0 \n\t" /* Y0U0 Y1V0 Y2U0 Y3V0*/
"punpckhbw %%mm1, %%mm3 \n\t" /* Y4U1 Y5V1 Y6U1 Y7V1*/
MOVNTQ" %%mm0, (%4, %0, 8) \n\t"
MOVNTQ" %%mm3, 8(%4, %0, 8) \n\t"
"punpckhbw %%mm2, %%mm6 \n\t" /* U2V2 U2V2 U3V3 U3V3*/
"movq 8(%1, %0, 4), %%mm0 \n\t"
"movq %%mm0, %%mm3 \n\t"
"punpcklbw %%mm6, %%mm0 \n\t" /* Y U2 Y V2 Y U2 Y V2*/
"punpckhbw %%mm6, %%mm3 \n\t" /* Y U3 Y V3 Y U3 Y V3*/
MOVNTQ" %%mm0, 16(%4, %0, 8) \n\t"
MOVNTQ" %%mm3, 24(%4, %0, 8) \n\t"
"movq %%mm4, %%mm6 \n\t"
"movq 16(%1, %0, 4), %%mm0 \n\t"
"movq %%mm0, %%mm3 \n\t"
"punpcklbw %%mm5, %%mm4 \n\t"
"punpcklbw %%mm4, %%mm0 \n\t" /* Y U4 Y V4 Y U4 Y V4*/
"punpckhbw %%mm4, %%mm3 \n\t" /* Y U5 Y V5 Y U5 Y V5*/
MOVNTQ" %%mm0, 32(%4, %0, 8) \n\t"
MOVNTQ" %%mm3, 40(%4, %0, 8) \n\t"
"punpckhbw %%mm5, %%mm6 \n\t"
"movq 24(%1, %0, 4), %%mm0 \n\t"
"movq %%mm0, %%mm3 \n\t"
"punpcklbw %%mm6, %%mm0 \n\t" /* Y U6 Y V6 Y U6 Y V6*/
"punpckhbw %%mm6, %%mm3 \n\t" /* Y U7 Y V7 Y U7 Y V7*/
MOVNTQ" %%mm0, 48(%4, %0, 8) \n\t"
MOVNTQ" %%mm3, 56(%4, %0, 8) \n\t"
: "+r" (x)
: "r"(yp), "r" (up), "r"(vp), "r"(d)
:"memory");
}
for (; x<w; x++) {
const int x2 = x<<2;
d[8*x+0] = yp[x2];
d[8*x+1] = up[x];
d[8*x+2] = yp[x2+1];
d[8*x+3] = vp[x];
d[8*x+4] = yp[x2+2];
d[8*x+5] = up[x];
d[8*x+6] = yp[x2+3];
d[8*x+7] = vp[x];
}
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
static void RENAME(extract_even)(const uint8_t *src, uint8_t *dst, x86_reg count)
{
dst += count;
src += 2*count;
count= - count;
if(count <= -16) {
count += 15;
__asm__ volatile(
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t"
"1: \n\t"
"movq -30(%1, %0, 2), %%mm0 \n\t"
"movq -22(%1, %0, 2), %%mm1 \n\t"
"movq -14(%1, %0, 2), %%mm2 \n\t"
"movq -6(%1, %0, 2), %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
MOVNTQ" %%mm0,-15(%2, %0) \n\t"
MOVNTQ" %%mm2,- 7(%2, %0) \n\t"
"add $16, %0 \n\t"
" js 1b \n\t"
: "+r"(count)
: "r"(src), "r"(dst)
);
count -= 15;
}
while(count<0) {
dst[count]= src[2*count];
count++;
}
}
#if !COMPILE_TEMPLATE_AMD3DNOW
static void RENAME(extract_even2)(const uint8_t *src, uint8_t *dst0, uint8_t *dst1, x86_reg count)
{
dst0+= count;
dst1+= count;
src += 4*count;
count= - count;
if(count <= -8) {
count += 7;
__asm__ volatile(
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t"
"1: \n\t"
"movq -28(%1, %0, 4), %%mm0 \n\t"
"movq -20(%1, %0, 4), %%mm1 \n\t"
"movq -12(%1, %0, 4), %%mm2 \n\t"
"movq -4(%1, %0, 4), %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm2 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm2, %%mm0 \n\t"
"packuswb %%mm3, %%mm1 \n\t"
MOVNTQ" %%mm0,- 7(%3, %0) \n\t"
MOVNTQ" %%mm1,- 7(%2, %0) \n\t"
"add $8, %0 \n\t"
" js 1b \n\t"
: "+r"(count)
: "r"(src), "r"(dst0), "r"(dst1)
);
count -= 7;
}
while(count<0) {
dst0[count]= src[4*count+0];
dst1[count]= src[4*count+2];
count++;
}
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
static void RENAME(extract_even2avg)(const uint8_t *src0, const uint8_t *src1, uint8_t *dst0, uint8_t *dst1, x86_reg count)
{
dst0 += count;
dst1 += count;
src0 += 4*count;
src1 += 4*count;
count= - count;
#ifdef PAVGB
if(count <= -8) {
count += 7;
__asm__ volatile(
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t"
"1: \n\t"
"movq -28(%1, %0, 4), %%mm0 \n\t"
"movq -20(%1, %0, 4), %%mm1 \n\t"
"movq -12(%1, %0, 4), %%mm2 \n\t"
"movq -4(%1, %0, 4), %%mm3 \n\t"
PAVGB" -28(%2, %0, 4), %%mm0 \n\t"
PAVGB" -20(%2, %0, 4), %%mm1 \n\t"
PAVGB" -12(%2, %0, 4), %%mm2 \n\t"
PAVGB" - 4(%2, %0, 4), %%mm3 \n\t"
"pand %%mm7, %%mm0 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm2 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm2 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm2, %%mm0 \n\t"
"packuswb %%mm3, %%mm1 \n\t"
MOVNTQ" %%mm0,- 7(%4, %0) \n\t"
MOVNTQ" %%mm1,- 7(%3, %0) \n\t"
"add $8, %0 \n\t"
" js 1b \n\t"
: "+r"(count)
: "r"(src0), "r"(src1), "r"(dst0), "r"(dst1)
);
count -= 7;
}
#endif
while(count<0) {
dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
count++;
}
}
#if !COMPILE_TEMPLATE_AMD3DNOW
static void RENAME(extract_odd2)(const uint8_t *src, uint8_t *dst0, uint8_t *dst1, x86_reg count)
{
dst0+= count;
dst1+= count;
src += 4*count;
count= - count;
if(count <= -8) {
count += 7;
__asm__ volatile(
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t"
"1: \n\t"
"movq -28(%1, %0, 4), %%mm0 \n\t"
"movq -20(%1, %0, 4), %%mm1 \n\t"
"movq -12(%1, %0, 4), %%mm2 \n\t"
"movq -4(%1, %0, 4), %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm2 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm2, %%mm0 \n\t"
"packuswb %%mm3, %%mm1 \n\t"
MOVNTQ" %%mm0,- 7(%3, %0) \n\t"
MOVNTQ" %%mm1,- 7(%2, %0) \n\t"
"add $8, %0 \n\t"
" js 1b \n\t"
: "+r"(count)
: "r"(src), "r"(dst0), "r"(dst1)
);
count -= 7;
}
src++;
while(count<0) {
dst0[count]= src[4*count+0];
dst1[count]= src[4*count+2];
count++;
}
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
static void RENAME(extract_odd2avg)(const uint8_t *src0, const uint8_t *src1, uint8_t *dst0, uint8_t *dst1, x86_reg count)
{
dst0 += count;
dst1 += count;
src0 += 4*count;
src1 += 4*count;
count= - count;
#ifdef PAVGB
if(count <= -8) {
count += 7;
__asm__ volatile(
"pcmpeqw %%mm7, %%mm7 \n\t"
"psrlw $8, %%mm7 \n\t"
"1: \n\t"
"movq -28(%1, %0, 4), %%mm0 \n\t"
"movq -20(%1, %0, 4), %%mm1 \n\t"
"movq -12(%1, %0, 4), %%mm2 \n\t"
"movq -4(%1, %0, 4), %%mm3 \n\t"
PAVGB" -28(%2, %0, 4), %%mm0 \n\t"
PAVGB" -20(%2, %0, 4), %%mm1 \n\t"
PAVGB" -12(%2, %0, 4), %%mm2 \n\t"
PAVGB" - 4(%2, %0, 4), %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, %%mm1 \n\t"
"movq %%mm2, %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm2 \n\t"
"pand %%mm7, %%mm1 \n\t"
"pand %%mm7, %%mm3 \n\t"
"packuswb %%mm2, %%mm0 \n\t"
"packuswb %%mm3, %%mm1 \n\t"
MOVNTQ" %%mm0,- 7(%4, %0) \n\t"
MOVNTQ" %%mm1,- 7(%3, %0) \n\t"
"add $8, %0 \n\t"
" js 1b \n\t"
: "+r"(count)
: "r"(src0), "r"(src1), "r"(dst0), "r"(dst1)
);
count -= 7;
}
#endif
src0++;
src1++;
while(count<0) {
dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
count++;
}
}
static void RENAME(yuyvtoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const int chromWidth= -((-width)>>1);
for (y=0; y<height; y++) {
RENAME(extract_even)(src, ydst, width);
if(y&1) {
RENAME(extract_odd2avg)(src-srcStride, src, udst, vdst, chromWidth);
udst+= chromStride;
vdst+= chromStride;
}
src += srcStride;
ydst+= lumStride;
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#if !COMPILE_TEMPLATE_AMD3DNOW
static void RENAME(yuyvtoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const int chromWidth= -((-width)>>1);
for (y=0; y<height; y++) {
RENAME(extract_even)(src, ydst, width);
RENAME(extract_odd2)(src, udst, vdst, chromWidth);
src += srcStride;
ydst+= lumStride;
udst+= chromStride;
vdst+= chromStride;
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
static void RENAME(uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const int chromWidth= -((-width)>>1);
for (y=0; y<height; y++) {
RENAME(extract_even)(src+1, ydst, width);
if(y&1) {
RENAME(extract_even2avg)(src-srcStride, src, udst, vdst, chromWidth);
udst+= chromStride;
vdst+= chromStride;
}
src += srcStride;
ydst+= lumStride;
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#if !COMPILE_TEMPLATE_AMD3DNOW
static void RENAME(uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
int width, int height,
int lumStride, int chromStride, int srcStride)
{
int y;
const int chromWidth= -((-width)>>1);
for (y=0; y<height; y++) {
RENAME(extract_even)(src+1, ydst, width);
RENAME(extract_even2)(src, udst, vdst, chromWidth);
src += srcStride;
ydst+= lumStride;
udst+= chromStride;
vdst+= chromStride;
}
__asm__(
EMMS" \n\t"
SFENCE" \n\t"
::: "memory"
);
}
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
#endif /* !COMPILE_TEMPLATE_SSE2 */
static inline void RENAME(rgb2rgb_init)(void)
{
#if !COMPILE_TEMPLATE_SSE2
#if !COMPILE_TEMPLATE_AMD3DNOW
rgb15to16 = RENAME(rgb15to16);
rgb15tobgr24 = RENAME(rgb15tobgr24);
rgb15to32 = RENAME(rgb15to32);
rgb16tobgr24 = RENAME(rgb16tobgr24);
rgb16to32 = RENAME(rgb16to32);
rgb16to15 = RENAME(rgb16to15);
rgb24tobgr16 = RENAME(rgb24tobgr16);
rgb24tobgr15 = RENAME(rgb24tobgr15);
rgb24tobgr32 = RENAME(rgb24tobgr32);
rgb32to16 = RENAME(rgb32to16);
rgb32to15 = RENAME(rgb32to15);
rgb32tobgr24 = RENAME(rgb32tobgr24);
rgb24to15 = RENAME(rgb24to15);
rgb24to16 = RENAME(rgb24to16);
rgb24tobgr24 = RENAME(rgb24tobgr24);
shuffle_bytes_2103 = RENAME(shuffle_bytes_2103);
rgb32tobgr16 = RENAME(rgb32tobgr16);
rgb32tobgr15 = RENAME(rgb32tobgr15);
yv12toyuy2 = RENAME(yv12toyuy2);
yv12touyvy = RENAME(yv12touyvy);
yuv422ptoyuy2 = RENAME(yuv422ptoyuy2);
yuv422ptouyvy = RENAME(yuv422ptouyvy);
yuy2toyv12 = RENAME(yuy2toyv12);
vu9_to_vu12 = RENAME(vu9_to_vu12);
yvu9_to_yuy2 = RENAME(yvu9_to_yuy2);
uyvytoyuv422 = RENAME(uyvytoyuv422);
yuyvtoyuv422 = RENAME(yuyvtoyuv422);
#endif /* !COMPILE_TEMPLATE_SSE2 */
#if COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW
planar2x = RENAME(planar2x);
#endif /* COMPILE_TEMPLATE_MMX2 || COMPILE_TEMPLATE_AMD3DNOW */
rgb24toyv12 = RENAME(rgb24toyv12);
yuyvtoyuv420 = RENAME(yuyvtoyuv420);
uyvytoyuv420 = RENAME(uyvytoyuv420);
#endif /* COMPILE_TEMPLATE_SSE2 */
#if !COMPILE_TEMPLATE_AMD3DNOW
interleaveBytes = RENAME(interleaveBytes);
#endif /* !COMPILE_TEMPLATE_AMD3DNOW */
}
| gpl-2.0 |
freak97/binutils | bfd/coff-ia64.c | 6054 | /* BFD back-end for HP/Intel IA-64 COFF files.
Copyright (C) 1999-2016 Free Software Foundation, Inc.
Contributed by David Mosberger <[email protected]>
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "coff/ia64.h"
#include "coff/internal.h"
#include "coff/pe.h"
#include "libcoff.h"
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
/* Windows ia64 uses 8K page size. */
#define COFF_PAGE_SIZE 0x2000
static reloc_howto_type howto_table[] =
{
EMPTY_HOWTO (0),
};
#define BADMAG(x) IA64BADMAG(x)
#define IA64 1 /* Customize coffcode.h */
#ifdef COFF_WITH_pep
# undef AOUTSZ
# define AOUTSZ PEPAOUTSZ
# define PEAOUTHDR PEPAOUTHDR
#endif
#define RTYPE2HOWTO(cache_ptr, dst) \
(cache_ptr)->howto = howto_table;
#ifdef COFF_WITH_PE
/* Return TRUE if this relocation should
appear in the output .reloc section. */
static bfd_boolean
in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
reloc_howto_type *howto ATTRIBUTE_UNUSED)
{
return FALSE; /* We don't do relocs for now... */
}
#endif
#ifndef bfd_pe_print_pdata
#define bfd_pe_print_pdata NULL
#endif
#include "coffcode.h"
static const bfd_target *
ia64coff_object_p (bfd *abfd)
{
#ifdef COFF_IMAGE_WITH_PE
{
struct external_PEI_DOS_hdr dos_hdr;
struct external_PEI_IMAGE_hdr image_hdr;
file_ptr offset;
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|| (bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd)
!= sizeof (dos_hdr)))
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* There are really two magic numbers involved; the magic number
that says this is a NT executable (PEI) and the magic number
that determines the architecture. The former is DOSMAGIC,
stored in the e_magic field. The latter is stored in the
f_magic field. If the NT magic number isn't valid, the
architecture magic number could be mimicked by some other
field (specifically, the number of relocs in section 3). Since
this routine can only be called correctly for a PEI file, check
the e_magic number here, and, if it doesn't match, clobber the
f_magic number so that we don't get a false match. */
if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
offset = H_GET_32 (abfd, dos_hdr.e_lfanew);
if (bfd_seek (abfd, offset, SEEK_SET) != 0
|| (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd)
!= sizeof (image_hdr)))
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
if (H_GET_32 (abfd, image_hdr.nt_signature)
!= 0x4550)
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
/* Here is the hack. coff_object_p wants to read filhsz bytes to
pick up the COFF header for PE, see "struct external_PEI_filehdr"
in include/coff/pe.h. We adjust so that that will work. */
if (bfd_seek (abfd, offset - sizeof (dos_hdr), SEEK_SET) != 0)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_wrong_format);
return NULL;
}
}
#endif
return coff_object_p (abfd);
}
const bfd_target
#ifdef TARGET_SYM
TARGET_SYM =
#else
ia64coff_vec =
#endif
{
#ifdef TARGET_NAME
TARGET_NAME,
#else
"coff-ia64", /* name */
#endif
bfd_target_coff_flavour,
BFD_ENDIAN_LITTLE, /* data byte order is little */
BFD_ENDIAN_LITTLE, /* header byte order is little */
(HAS_RELOC | EXEC_P | /* object flags */
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
#ifndef COFF_WITH_PE
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
| SEC_CODE | SEC_DATA),
#else
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
| SEC_CODE | SEC_DATA
| SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
#endif
#ifdef TARGET_UNDERSCORE
TARGET_UNDERSCORE, /* leading underscore */
#else
0, /* leading underscore */
#endif
'/', /* ar_pad_char */
15, /* ar_max_namelen */
0, /* match priority. */
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
/* Note that we allow an object file to be treated as a core file as well. */
{_bfd_dummy_target, ia64coff_object_p, /* bfd_check_format */
bfd_generic_archive_p, ia64coff_object_p},
{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
bfd_false},
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
_bfd_write_archive_contents, bfd_false},
BFD_JUMP_TABLE_GENERIC (coff),
BFD_JUMP_TABLE_COPY (coff),
BFD_JUMP_TABLE_CORE (_bfd_nocore),
BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
BFD_JUMP_TABLE_SYMBOLS (coff),
BFD_JUMP_TABLE_RELOCS (coff),
BFD_JUMP_TABLE_WRITE (coff),
BFD_JUMP_TABLE_LINK (coff),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
NULL,
COFF_SWAP_TABLE
};
| gpl-2.0 |
BPI-SINOVOIP/BPI-Mainline-kernel | linux-4.14/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c | 62226 | /*
* cxgb4i.c: Chelsio T4 iSCSI driver.
*
* Copyright (c) 2010-2015 Chelsio Communications, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation.
*
* Written by: Karen Xie ([email protected])
* Rakesh Ranjan ([email protected])
*/
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <scsi/scsi_host.h>
#include <net/tcp.h>
#include <net/dst.h>
#include <linux/netdevice.h>
#include <net/addrconf.h>
#include "t4_regs.h"
#include "t4_msg.h"
#include "cxgb4.h"
#include "cxgb4_uld.h"
#include "t4fw_api.h"
#include "l2t.h"
#include "cxgb4i.h"
#include "clip_tbl.h"
static unsigned int dbg_level;
#include "../libcxgbi.h"
#define DRV_MODULE_NAME "cxgb4i"
#define DRV_MODULE_DESC "Chelsio T4-T6 iSCSI Driver"
#define DRV_MODULE_VERSION "0.9.5-ko"
#define DRV_MODULE_RELDATE "Apr. 2015"
static char version[] =
DRV_MODULE_DESC " " DRV_MODULE_NAME
" v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
MODULE_AUTHOR("Chelsio Communications, Inc.");
MODULE_DESCRIPTION(DRV_MODULE_DESC);
MODULE_VERSION(DRV_MODULE_VERSION);
MODULE_LICENSE("GPL");
module_param(dbg_level, uint, 0644);
MODULE_PARM_DESC(dbg_level, "Debug flag (default=0)");
#define CXGB4I_DEFAULT_10G_RCV_WIN (256 * 1024)
static int cxgb4i_rcv_win = -1;
module_param(cxgb4i_rcv_win, int, 0644);
MODULE_PARM_DESC(cxgb4i_rcv_win, "TCP reveive window in bytes");
#define CXGB4I_DEFAULT_10G_SND_WIN (128 * 1024)
static int cxgb4i_snd_win = -1;
module_param(cxgb4i_snd_win, int, 0644);
MODULE_PARM_DESC(cxgb4i_snd_win, "TCP send window in bytes");
static int cxgb4i_rx_credit_thres = 10 * 1024;
module_param(cxgb4i_rx_credit_thres, int, 0644);
MODULE_PARM_DESC(cxgb4i_rx_credit_thres,
"RX credits return threshold in bytes (default=10KB)");
static unsigned int cxgb4i_max_connect = (8 * 1024);
module_param(cxgb4i_max_connect, uint, 0644);
MODULE_PARM_DESC(cxgb4i_max_connect, "Maximum number of connections");
static unsigned short cxgb4i_sport_base = 20000;
module_param(cxgb4i_sport_base, ushort, 0644);
MODULE_PARM_DESC(cxgb4i_sport_base, "Starting port number (default 20000)");
typedef void (*cxgb4i_cplhandler_func)(struct cxgbi_device *, struct sk_buff *);
static void *t4_uld_add(const struct cxgb4_lld_info *);
static int t4_uld_rx_handler(void *, const __be64 *, const struct pkt_gl *);
static int t4_uld_state_change(void *, enum cxgb4_state state);
static inline int send_tx_flowc_wr(struct cxgbi_sock *);
static const struct cxgb4_uld_info cxgb4i_uld_info = {
.name = DRV_MODULE_NAME,
.nrxq = MAX_ULD_QSETS,
.ntxq = MAX_ULD_QSETS,
.rxq_size = 1024,
.lro = false,
.add = t4_uld_add,
.rx_handler = t4_uld_rx_handler,
.state_change = t4_uld_state_change,
};
static struct scsi_host_template cxgb4i_host_template = {
.module = THIS_MODULE,
.name = DRV_MODULE_NAME,
.proc_name = DRV_MODULE_NAME,
.can_queue = CXGB4I_SCSI_HOST_QDEPTH,
.queuecommand = iscsi_queuecommand,
.change_queue_depth = scsi_change_queue_depth,
.sg_tablesize = SG_ALL,
.max_sectors = 0xFFFF,
.cmd_per_lun = ISCSI_DEF_CMD_PER_LUN,
.eh_timed_out = iscsi_eh_cmd_timed_out,
.eh_abort_handler = iscsi_eh_abort,
.eh_device_reset_handler = iscsi_eh_device_reset,
.eh_target_reset_handler = iscsi_eh_recover_target,
.target_alloc = iscsi_target_alloc,
.use_clustering = DISABLE_CLUSTERING,
.this_id = -1,
.track_queue_depth = 1,
};
static struct iscsi_transport cxgb4i_iscsi_transport = {
.owner = THIS_MODULE,
.name = DRV_MODULE_NAME,
.caps = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST |
CAP_DATADGST | CAP_DIGEST_OFFLOAD |
CAP_PADDING_OFFLOAD | CAP_TEXT_NEGO,
.attr_is_visible = cxgbi_attr_is_visible,
.get_host_param = cxgbi_get_host_param,
.set_host_param = cxgbi_set_host_param,
/* session management */
.create_session = cxgbi_create_session,
.destroy_session = cxgbi_destroy_session,
.get_session_param = iscsi_session_get_param,
/* connection management */
.create_conn = cxgbi_create_conn,
.bind_conn = cxgbi_bind_conn,
.destroy_conn = iscsi_tcp_conn_teardown,
.start_conn = iscsi_conn_start,
.stop_conn = iscsi_conn_stop,
.get_conn_param = iscsi_conn_get_param,
.set_param = cxgbi_set_conn_param,
.get_stats = cxgbi_get_conn_stats,
/* pdu xmit req from user space */
.send_pdu = iscsi_conn_send_pdu,
/* task */
.init_task = iscsi_tcp_task_init,
.xmit_task = iscsi_tcp_task_xmit,
.cleanup_task = cxgbi_cleanup_task,
/* pdu */
.alloc_pdu = cxgbi_conn_alloc_pdu,
.init_pdu = cxgbi_conn_init_pdu,
.xmit_pdu = cxgbi_conn_xmit_pdu,
.parse_pdu_itt = cxgbi_parse_pdu_itt,
/* TCP connect/disconnect */
.get_ep_param = cxgbi_get_ep_param,
.ep_connect = cxgbi_ep_connect,
.ep_poll = cxgbi_ep_poll,
.ep_disconnect = cxgbi_ep_disconnect,
/* Error recovery timeout call */
.session_recovery_timedout = iscsi_session_recovery_timedout,
};
static struct scsi_transport_template *cxgb4i_stt;
/*
* CPL (Chelsio Protocol Language) defines a message passing interface between
* the host driver and Chelsio asic.
* The section below implments CPLs that related to iscsi tcp connection
* open/close/abort and data send/receive.
*/
#define RCV_BUFSIZ_MASK 0x3FFU
#define MAX_IMM_TX_PKT_LEN 256
static int push_tx_frames(struct cxgbi_sock *, int);
/*
* is_ofld_imm - check whether a packet can be sent as immediate data
* @skb: the packet
*
* Returns true if a packet can be sent as an offload WR with immediate
* data. We currently use the same limit as for Ethernet packets.
*/
static inline bool is_ofld_imm(const struct sk_buff *skb)
{
int len = skb->len;
if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))
len += sizeof(struct fw_ofld_tx_data_wr);
return len <= MAX_IMM_TX_PKT_LEN;
}
static void send_act_open_req(struct cxgbi_sock *csk, struct sk_buff *skb,
struct l2t_entry *e)
{
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(csk->cdev);
int wscale = cxgbi_sock_compute_wscale(csk->mss_idx);
unsigned long long opt0;
unsigned int opt2;
unsigned int qid_atid = ((unsigned int)csk->atid) |
(((unsigned int)csk->rss_qid) << 14);
opt0 = KEEP_ALIVE_F |
WND_SCALE_V(wscale) |
MSS_IDX_V(csk->mss_idx) |
L2T_IDX_V(((struct l2t_entry *)csk->l2t)->idx) |
TX_CHAN_V(csk->tx_chan) |
SMAC_SEL_V(csk->smac_idx) |
ULP_MODE_V(ULP_MODE_ISCSI) |
RCV_BUFSIZ_V(csk->rcv_win >> 10);
opt2 = RX_CHANNEL_V(0) |
RSS_QUEUE_VALID_F |
RSS_QUEUE_V(csk->rss_qid);
if (is_t4(lldi->adapter_type)) {
struct cpl_act_open_req *req =
(struct cpl_act_open_req *)skb->head;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ,
qid_atid));
req->local_port = csk->saddr.sin_port;
req->peer_port = csk->daddr.sin_port;
req->local_ip = csk->saddr.sin_addr.s_addr;
req->peer_ip = csk->daddr.sin_addr.s_addr;
req->opt0 = cpu_to_be64(opt0);
req->params = cpu_to_be32(cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t));
opt2 |= RX_FC_VALID_F;
req->opt2 = cpu_to_be32(opt2);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk t4 0x%p, %pI4:%u-%pI4:%u, atid %d, qid %u.\n",
csk, &req->local_ip, ntohs(req->local_port),
&req->peer_ip, ntohs(req->peer_port),
csk->atid, csk->rss_qid);
} else if (is_t5(lldi->adapter_type)) {
struct cpl_t5_act_open_req *req =
(struct cpl_t5_act_open_req *)skb->head;
u32 isn = (prandom_u32() & ~7UL) - 1;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ,
qid_atid));
req->local_port = csk->saddr.sin_port;
req->peer_port = csk->daddr.sin_port;
req->local_ip = csk->saddr.sin_addr.s_addr;
req->peer_ip = csk->daddr.sin_addr.s_addr;
req->opt0 = cpu_to_be64(opt0);
req->params = cpu_to_be64(FILTER_TUPLE_V(
cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t)));
req->rsvd = cpu_to_be32(isn);
opt2 |= T5_ISS_VALID;
opt2 |= T5_OPT_2_VALID_F;
req->opt2 = cpu_to_be32(opt2);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk t5 0x%p, %pI4:%u-%pI4:%u, atid %d, qid %u.\n",
csk, &req->local_ip, ntohs(req->local_port),
&req->peer_ip, ntohs(req->peer_port),
csk->atid, csk->rss_qid);
} else {
struct cpl_t6_act_open_req *req =
(struct cpl_t6_act_open_req *)skb->head;
u32 isn = (prandom_u32() & ~7UL) - 1;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ,
qid_atid));
req->local_port = csk->saddr.sin_port;
req->peer_port = csk->daddr.sin_port;
req->local_ip = csk->saddr.sin_addr.s_addr;
req->peer_ip = csk->daddr.sin_addr.s_addr;
req->opt0 = cpu_to_be64(opt0);
req->params = cpu_to_be64(FILTER_TUPLE_V(
cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t)));
req->rsvd = cpu_to_be32(isn);
opt2 |= T5_ISS_VALID;
opt2 |= RX_FC_DISABLE_F;
opt2 |= T5_OPT_2_VALID_F;
req->opt2 = cpu_to_be32(opt2);
req->rsvd2 = cpu_to_be32(0);
req->opt3 = cpu_to_be32(0);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk t6 0x%p, %pI4:%u-%pI4:%u, atid %d, qid %u.\n",
csk, &req->local_ip, ntohs(req->local_port),
&req->peer_ip, ntohs(req->peer_port),
csk->atid, csk->rss_qid);
}
set_wr_txq(skb, CPL_PRIORITY_SETUP, csk->port_id);
pr_info_ipaddr("t%d csk 0x%p,%u,0x%lx,%u, rss_qid %u.\n",
(&csk->saddr), (&csk->daddr),
CHELSIO_CHIP_VERSION(lldi->adapter_type), csk,
csk->state, csk->flags, csk->atid, csk->rss_qid);
cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
}
#if IS_ENABLED(CONFIG_IPV6)
static void send_act_open_req6(struct cxgbi_sock *csk, struct sk_buff *skb,
struct l2t_entry *e)
{
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(csk->cdev);
int wscale = cxgbi_sock_compute_wscale(csk->mss_idx);
unsigned long long opt0;
unsigned int opt2;
unsigned int qid_atid = ((unsigned int)csk->atid) |
(((unsigned int)csk->rss_qid) << 14);
opt0 = KEEP_ALIVE_F |
WND_SCALE_V(wscale) |
MSS_IDX_V(csk->mss_idx) |
L2T_IDX_V(((struct l2t_entry *)csk->l2t)->idx) |
TX_CHAN_V(csk->tx_chan) |
SMAC_SEL_V(csk->smac_idx) |
ULP_MODE_V(ULP_MODE_ISCSI) |
RCV_BUFSIZ_V(csk->rcv_win >> 10);
opt2 = RX_CHANNEL_V(0) |
RSS_QUEUE_VALID_F |
RSS_QUEUE_V(csk->rss_qid);
if (is_t4(lldi->adapter_type)) {
struct cpl_act_open_req6 *req =
(struct cpl_act_open_req6 *)skb->head;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6,
qid_atid));
req->local_port = csk->saddr6.sin6_port;
req->peer_port = csk->daddr6.sin6_port;
req->local_ip_hi = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr);
req->local_ip_lo = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr +
8);
req->peer_ip_hi = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr);
req->peer_ip_lo = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr +
8);
req->opt0 = cpu_to_be64(opt0);
opt2 |= RX_FC_VALID_F;
req->opt2 = cpu_to_be32(opt2);
req->params = cpu_to_be32(cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t));
} else if (is_t5(lldi->adapter_type)) {
struct cpl_t5_act_open_req6 *req =
(struct cpl_t5_act_open_req6 *)skb->head;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6,
qid_atid));
req->local_port = csk->saddr6.sin6_port;
req->peer_port = csk->daddr6.sin6_port;
req->local_ip_hi = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr);
req->local_ip_lo = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr +
8);
req->peer_ip_hi = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr);
req->peer_ip_lo = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr +
8);
req->opt0 = cpu_to_be64(opt0);
opt2 |= T5_OPT_2_VALID_F;
req->opt2 = cpu_to_be32(opt2);
req->params = cpu_to_be64(FILTER_TUPLE_V(cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t)));
} else {
struct cpl_t6_act_open_req6 *req =
(struct cpl_t6_act_open_req6 *)skb->head;
INIT_TP_WR(req, 0);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6,
qid_atid));
req->local_port = csk->saddr6.sin6_port;
req->peer_port = csk->daddr6.sin6_port;
req->local_ip_hi = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr);
req->local_ip_lo = *(__be64 *)(csk->saddr6.sin6_addr.s6_addr +
8);
req->peer_ip_hi = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr);
req->peer_ip_lo = *(__be64 *)(csk->daddr6.sin6_addr.s6_addr +
8);
req->opt0 = cpu_to_be64(opt0);
opt2 |= RX_FC_DISABLE_F;
opt2 |= T5_OPT_2_VALID_F;
req->opt2 = cpu_to_be32(opt2);
req->params = cpu_to_be64(FILTER_TUPLE_V(cxgb4_select_ntuple(
csk->cdev->ports[csk->port_id],
csk->l2t)));
req->rsvd2 = cpu_to_be32(0);
req->opt3 = cpu_to_be32(0);
}
set_wr_txq(skb, CPL_PRIORITY_SETUP, csk->port_id);
pr_info("t%d csk 0x%p,%u,0x%lx,%u, [%pI6]:%u-[%pI6]:%u, rss_qid %u.\n",
CHELSIO_CHIP_VERSION(lldi->adapter_type), csk, csk->state,
csk->flags, csk->atid,
&csk->saddr6.sin6_addr, ntohs(csk->saddr.sin_port),
&csk->daddr6.sin6_addr, ntohs(csk->daddr.sin_port),
csk->rss_qid);
cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
}
#endif
static void send_close_req(struct cxgbi_sock *csk)
{
struct sk_buff *skb = csk->cpl_close;
struct cpl_close_con_req *req = (struct cpl_close_con_req *)skb->head;
unsigned int tid = csk->tid;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx, tid %u.\n",
csk, csk->state, csk->flags, csk->tid);
csk->cpl_close = NULL;
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
INIT_TP_WR(req, tid);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, tid));
req->rsvd = 0;
cxgbi_sock_skb_entail(csk, skb);
if (csk->state >= CTP_ESTABLISHED)
push_tx_frames(csk, 1);
}
static void abort_arp_failure(void *handle, struct sk_buff *skb)
{
struct cxgbi_sock *csk = (struct cxgbi_sock *)handle;
struct cpl_abort_req *req;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx, tid %u, abort.\n",
csk, csk->state, csk->flags, csk->tid);
req = (struct cpl_abort_req *)skb->data;
req->cmd = CPL_ABORT_NO_RST;
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
}
static void send_abort_req(struct cxgbi_sock *csk)
{
struct cpl_abort_req *req;
struct sk_buff *skb = csk->cpl_abort_req;
if (unlikely(csk->state == CTP_ABORTING) || !skb || !csk->cdev)
return;
if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT)) {
send_tx_flowc_wr(csk);
cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);
}
cxgbi_sock_set_state(csk, CTP_ABORTING);
cxgbi_sock_set_flag(csk, CTPF_ABORT_RPL_PENDING);
cxgbi_sock_purge_write_queue(csk);
csk->cpl_abort_req = NULL;
req = (struct cpl_abort_req *)skb->head;
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
req->cmd = CPL_ABORT_SEND_RST;
t4_set_arp_err_handler(skb, csk, abort_arp_failure);
INIT_TP_WR(req, csk->tid);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, csk->tid));
req->rsvd0 = htonl(csk->snd_nxt);
req->rsvd1 = !cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, snd_nxt %u, 0x%x.\n",
csk, csk->state, csk->flags, csk->tid, csk->snd_nxt,
req->rsvd1);
cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
}
static void send_abort_rpl(struct cxgbi_sock *csk, int rst_status)
{
struct sk_buff *skb = csk->cpl_abort_rpl;
struct cpl_abort_rpl *rpl = (struct cpl_abort_rpl *)skb->head;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, status %d.\n",
csk, csk->state, csk->flags, csk->tid, rst_status);
csk->cpl_abort_rpl = NULL;
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
INIT_TP_WR(rpl, csk->tid);
OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, csk->tid));
rpl->cmd = rst_status;
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
}
/*
* CPL connection rx data ack: host ->
* Send RX credits through an RX_DATA_ACK CPL message. Returns the number of
* credits sent.
*/
static u32 send_rx_credits(struct cxgbi_sock *csk, u32 credits)
{
struct sk_buff *skb;
struct cpl_rx_data_ack *req;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx,%u, credit %u.\n",
csk, csk->state, csk->flags, csk->tid, credits);
skb = alloc_wr(sizeof(*req), 0, GFP_ATOMIC);
if (!skb) {
pr_info("csk 0x%p, credit %u, OOM.\n", csk, credits);
return 0;
}
req = (struct cpl_rx_data_ack *)skb->head;
set_wr_txq(skb, CPL_PRIORITY_ACK, csk->port_id);
INIT_TP_WR(req, csk->tid);
OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK,
csk->tid));
req->credit_dack = cpu_to_be32(RX_CREDITS_V(credits)
| RX_FORCE_ACK_F);
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
return credits;
}
/*
* sgl_len - calculates the size of an SGL of the given capacity
* @n: the number of SGL entries
* Calculates the number of flits needed for a scatter/gather list that
* can hold the given number of entries.
*/
static inline unsigned int sgl_len(unsigned int n)
{
n--;
return (3 * n) / 2 + (n & 1) + 2;
}
/*
* calc_tx_flits_ofld - calculate # of flits for an offload packet
* @skb: the packet
*
* Returns the number of flits needed for the given offload packet.
* These packets are already fully constructed and no additional headers
* will be added.
*/
static inline unsigned int calc_tx_flits_ofld(const struct sk_buff *skb)
{
unsigned int flits, cnt;
if (is_ofld_imm(skb))
return DIV_ROUND_UP(skb->len, 8);
flits = skb_transport_offset(skb) / 8;
cnt = skb_shinfo(skb)->nr_frags;
if (skb_tail_pointer(skb) != skb_transport_header(skb))
cnt++;
return flits + sgl_len(cnt);
}
#define FLOWC_WR_NPARAMS_MIN 9
static inline int tx_flowc_wr_credits(int *nparamsp, int *flowclenp)
{
int nparams, flowclen16, flowclen;
nparams = FLOWC_WR_NPARAMS_MIN;
flowclen = offsetof(struct fw_flowc_wr, mnemval[nparams]);
flowclen16 = DIV_ROUND_UP(flowclen, 16);
flowclen = flowclen16 * 16;
/*
* Return the number of 16-byte credits used by the FlowC request.
* Pass back the nparams and actual FlowC length if requested.
*/
if (nparamsp)
*nparamsp = nparams;
if (flowclenp)
*flowclenp = flowclen;
return flowclen16;
}
static inline int send_tx_flowc_wr(struct cxgbi_sock *csk)
{
struct sk_buff *skb;
struct fw_flowc_wr *flowc;
int nparams, flowclen16, flowclen;
flowclen16 = tx_flowc_wr_credits(&nparams, &flowclen);
skb = alloc_wr(flowclen, 0, GFP_ATOMIC);
flowc = (struct fw_flowc_wr *)skb->head;
flowc->op_to_nparams =
htonl(FW_WR_OP_V(FW_FLOWC_WR) | FW_FLOWC_WR_NPARAMS_V(nparams));
flowc->flowid_len16 =
htonl(FW_WR_LEN16_V(flowclen16) | FW_WR_FLOWID_V(csk->tid));
flowc->mnemval[0].mnemonic = FW_FLOWC_MNEM_PFNVFN;
flowc->mnemval[0].val = htonl(csk->cdev->pfvf);
flowc->mnemval[1].mnemonic = FW_FLOWC_MNEM_CH;
flowc->mnemval[1].val = htonl(csk->tx_chan);
flowc->mnemval[2].mnemonic = FW_FLOWC_MNEM_PORT;
flowc->mnemval[2].val = htonl(csk->tx_chan);
flowc->mnemval[3].mnemonic = FW_FLOWC_MNEM_IQID;
flowc->mnemval[3].val = htonl(csk->rss_qid);
flowc->mnemval[4].mnemonic = FW_FLOWC_MNEM_SNDNXT;
flowc->mnemval[4].val = htonl(csk->snd_nxt);
flowc->mnemval[5].mnemonic = FW_FLOWC_MNEM_RCVNXT;
flowc->mnemval[5].val = htonl(csk->rcv_nxt);
flowc->mnemval[6].mnemonic = FW_FLOWC_MNEM_SNDBUF;
flowc->mnemval[6].val = htonl(csk->snd_win);
flowc->mnemval[7].mnemonic = FW_FLOWC_MNEM_MSS;
flowc->mnemval[7].val = htonl(csk->advmss);
flowc->mnemval[8].mnemonic = 0;
flowc->mnemval[8].val = 0;
flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;
flowc->mnemval[8].val = 16384;
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p, tid 0x%x, %u,%u,%u,%u,%u,%u,%u.\n",
csk, csk->tid, 0, csk->tx_chan, csk->rss_qid,
csk->snd_nxt, csk->rcv_nxt, csk->snd_win,
csk->advmss);
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
return flowclen16;
}
static inline void make_tx_data_wr(struct cxgbi_sock *csk, struct sk_buff *skb,
int dlen, int len, u32 credits, int compl)
{
struct fw_ofld_tx_data_wr *req;
unsigned int submode = cxgbi_skcb_ulp_mode(skb) & 3;
unsigned int wr_ulp_mode = 0, val;
bool imm = is_ofld_imm(skb);
req = __skb_push(skb, sizeof(*req));
if (imm) {
req->op_to_immdlen = htonl(FW_WR_OP_V(FW_OFLD_TX_DATA_WR) |
FW_WR_COMPL_F |
FW_WR_IMMDLEN_V(dlen));
req->flowid_len16 = htonl(FW_WR_FLOWID_V(csk->tid) |
FW_WR_LEN16_V(credits));
} else {
req->op_to_immdlen =
cpu_to_be32(FW_WR_OP_V(FW_OFLD_TX_DATA_WR) |
FW_WR_COMPL_F |
FW_WR_IMMDLEN_V(0));
req->flowid_len16 =
cpu_to_be32(FW_WR_FLOWID_V(csk->tid) |
FW_WR_LEN16_V(credits));
}
if (submode)
wr_ulp_mode = FW_OFLD_TX_DATA_WR_ULPMODE_V(ULP2_MODE_ISCSI) |
FW_OFLD_TX_DATA_WR_ULPSUBMODE_V(submode);
val = skb_peek(&csk->write_queue) ? 0 : 1;
req->tunnel_to_proxy = htonl(wr_ulp_mode |
FW_OFLD_TX_DATA_WR_SHOVE_V(val));
req->plen = htonl(len);
if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT))
cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);
}
static void arp_failure_skb_discard(void *handle, struct sk_buff *skb)
{
kfree_skb(skb);
}
static int push_tx_frames(struct cxgbi_sock *csk, int req_completion)
{
int total_size = 0;
struct sk_buff *skb;
if (unlikely(csk->state < CTP_ESTABLISHED ||
csk->state == CTP_CLOSE_WAIT_1 || csk->state >= CTP_ABORTING)) {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK |
1 << CXGBI_DBG_PDU_TX,
"csk 0x%p,%u,0x%lx,%u, in closing state.\n",
csk, csk->state, csk->flags, csk->tid);
return 0;
}
while (csk->wr_cred && (skb = skb_peek(&csk->write_queue)) != NULL) {
int dlen = skb->len;
int len = skb->len;
unsigned int credits_needed;
int flowclen16 = 0;
skb_reset_transport_header(skb);
if (is_ofld_imm(skb))
credits_needed = DIV_ROUND_UP(dlen, 16);
else
credits_needed = DIV_ROUND_UP(
8 * calc_tx_flits_ofld(skb),
16);
if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))
credits_needed += DIV_ROUND_UP(
sizeof(struct fw_ofld_tx_data_wr),
16);
/*
* Assumes the initial credits is large enough to support
* fw_flowc_wr plus largest possible first payload
*/
if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT)) {
flowclen16 = send_tx_flowc_wr(csk);
csk->wr_cred -= flowclen16;
csk->wr_una_cred += flowclen16;
cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);
}
if (csk->wr_cred < credits_needed) {
log_debug(1 << CXGBI_DBG_PDU_TX,
"csk 0x%p, skb %u/%u, wr %d < %u.\n",
csk, skb->len, skb->data_len,
credits_needed, csk->wr_cred);
break;
}
__skb_unlink(skb, &csk->write_queue);
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
skb->csum = credits_needed + flowclen16;
csk->wr_cred -= credits_needed;
csk->wr_una_cred += credits_needed;
cxgbi_sock_enqueue_wr(csk, skb);
log_debug(1 << CXGBI_DBG_PDU_TX,
"csk 0x%p, skb %u/%u, wr %d, left %u, unack %u.\n",
csk, skb->len, skb->data_len, credits_needed,
csk->wr_cred, csk->wr_una_cred);
if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR))) {
len += cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));
make_tx_data_wr(csk, skb, dlen, len, credits_needed,
req_completion);
csk->snd_nxt += len;
cxgbi_skcb_clear_flag(skb, SKCBF_TX_NEED_HDR);
} else if (cxgbi_skcb_test_flag(skb, SKCBF_TX_FLAG_COMPL) &&
(csk->wr_una_cred >= (csk->wr_max_cred / 2))) {
struct cpl_close_con_req *req =
(struct cpl_close_con_req *)skb->data;
req->wr.wr_hi |= htonl(FW_WR_COMPL_F);
}
total_size += skb->truesize;
t4_set_arp_err_handler(skb, csk, arp_failure_skb_discard);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_TX,
"csk 0x%p,%u,0x%lx,%u, skb 0x%p, %u.\n",
csk, csk->state, csk->flags, csk->tid, skb, len);
cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
}
return total_size;
}
static inline void free_atid(struct cxgbi_sock *csk)
{
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(csk->cdev);
if (cxgbi_sock_flag(csk, CTPF_HAS_ATID)) {
cxgb4_free_atid(lldi->tids, csk->atid);
cxgbi_sock_clear_flag(csk, CTPF_HAS_ATID);
cxgbi_sock_put(csk);
}
}
static void do_act_establish(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_act_establish *req = (struct cpl_act_establish *)skb->data;
unsigned short tcp_opt = ntohs(req->tcp_opt);
unsigned int tid = GET_TID(req);
unsigned int atid = TID_TID_G(ntohl(req->tos_atid));
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
u32 rcv_isn = be32_to_cpu(req->rcv_isn);
csk = lookup_atid(t, atid);
if (unlikely(!csk)) {
pr_err("NO conn. for atid %u, cdev 0x%p.\n", atid, cdev);
goto rel_skb;
}
if (csk->atid != atid) {
pr_err("bad conn atid %u, csk 0x%p,%u,0x%lx,tid %u, atid %u.\n",
atid, csk, csk->state, csk->flags, csk->tid, csk->atid);
goto rel_skb;
}
pr_info_ipaddr("atid 0x%x, tid 0x%x, csk 0x%p,%u,0x%lx, isn %u.\n",
(&csk->saddr), (&csk->daddr),
atid, tid, csk, csk->state, csk->flags, rcv_isn);
module_put(cdev->owner);
cxgbi_sock_get(csk);
csk->tid = tid;
cxgb4_insert_tid(lldi->tids, csk, tid, csk->csk_family);
cxgbi_sock_set_flag(csk, CTPF_HAS_TID);
free_atid(csk);
spin_lock_bh(&csk->lock);
if (unlikely(csk->state != CTP_ACTIVE_OPEN))
pr_info("csk 0x%p,%u,0x%lx,%u, got EST.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->retry_timer.function) {
del_timer(&csk->retry_timer);
csk->retry_timer.function = NULL;
}
csk->copied_seq = csk->rcv_wup = csk->rcv_nxt = rcv_isn;
/*
* Causes the first RX_DATA_ACK to supply any Rx credits we couldn't
* pass through opt0.
*/
if (csk->rcv_win > (RCV_BUFSIZ_MASK << 10))
csk->rcv_wup -= csk->rcv_win - (RCV_BUFSIZ_MASK << 10);
csk->advmss = lldi->mtus[TCPOPT_MSS_G(tcp_opt)] - 40;
if (TCPOPT_TSTAMP_G(tcp_opt))
csk->advmss -= 12;
if (csk->advmss < 128)
csk->advmss = 128;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p, mss_idx %u, advmss %u.\n",
csk, TCPOPT_MSS_G(tcp_opt), csk->advmss);
cxgbi_sock_established(csk, ntohl(req->snd_isn), ntohs(req->tcp_opt));
if (unlikely(cxgbi_sock_flag(csk, CTPF_ACTIVE_CLOSE_NEEDED)))
send_abort_req(csk);
else {
if (skb_queue_len(&csk->write_queue))
push_tx_frames(csk, 0);
cxgbi_conn_tx_open(csk);
}
spin_unlock_bh(&csk->lock);
rel_skb:
__kfree_skb(skb);
}
static int act_open_rpl_status_to_errno(int status)
{
switch (status) {
case CPL_ERR_CONN_RESET:
return -ECONNREFUSED;
case CPL_ERR_ARP_MISS:
return -EHOSTUNREACH;
case CPL_ERR_CONN_TIMEDOUT:
return -ETIMEDOUT;
case CPL_ERR_TCAM_FULL:
return -ENOMEM;
case CPL_ERR_CONN_EXIST:
return -EADDRINUSE;
default:
return -EIO;
}
}
static void csk_act_open_retry_timer(unsigned long data)
{
struct sk_buff *skb = NULL;
struct cxgbi_sock *csk = (struct cxgbi_sock *)data;
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(csk->cdev);
void (*send_act_open_func)(struct cxgbi_sock *, struct sk_buff *,
struct l2t_entry *);
int t4 = is_t4(lldi->adapter_type), size, size6;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u.\n",
csk, csk->state, csk->flags, csk->tid);
cxgbi_sock_get(csk);
spin_lock_bh(&csk->lock);
if (t4) {
size = sizeof(struct cpl_act_open_req);
size6 = sizeof(struct cpl_act_open_req6);
} else {
size = sizeof(struct cpl_t5_act_open_req);
size6 = sizeof(struct cpl_t5_act_open_req6);
}
if (csk->csk_family == AF_INET) {
send_act_open_func = send_act_open_req;
skb = alloc_wr(size, 0, GFP_ATOMIC);
#if IS_ENABLED(CONFIG_IPV6)
} else {
send_act_open_func = send_act_open_req6;
skb = alloc_wr(size6, 0, GFP_ATOMIC);
#endif
}
if (!skb)
cxgbi_sock_fail_act_open(csk, -ENOMEM);
else {
skb->sk = (struct sock *)csk;
t4_set_arp_err_handler(skb, csk,
cxgbi_sock_act_open_req_arp_failure);
send_act_open_func(csk, skb, csk->l2t);
}
spin_unlock_bh(&csk->lock);
cxgbi_sock_put(csk);
}
static inline bool is_neg_adv(unsigned int status)
{
return status == CPL_ERR_RTX_NEG_ADVICE ||
status == CPL_ERR_KEEPALV_NEG_ADVICE ||
status == CPL_ERR_PERSIST_NEG_ADVICE;
}
static void do_act_open_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_act_open_rpl *rpl = (struct cpl_act_open_rpl *)skb->data;
unsigned int tid = GET_TID(rpl);
unsigned int atid =
TID_TID_G(AOPEN_ATID_G(be32_to_cpu(rpl->atid_status)));
unsigned int status = AOPEN_STATUS_G(be32_to_cpu(rpl->atid_status));
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_atid(t, atid);
if (unlikely(!csk)) {
pr_err("NO matching conn. atid %u, tid %u.\n", atid, tid);
goto rel_skb;
}
pr_info_ipaddr("tid %u/%u, status %u.\n"
"csk 0x%p,%u,0x%lx. ", (&csk->saddr), (&csk->daddr),
atid, tid, status, csk, csk->state, csk->flags);
if (is_neg_adv(status))
goto rel_skb;
module_put(cdev->owner);
if (status && status != CPL_ERR_TCAM_FULL &&
status != CPL_ERR_CONN_EXIST &&
status != CPL_ERR_ARP_MISS)
cxgb4_remove_tid(lldi->tids, csk->port_id, GET_TID(rpl),
csk->csk_family);
cxgbi_sock_get(csk);
spin_lock_bh(&csk->lock);
if (status == CPL_ERR_CONN_EXIST &&
csk->retry_timer.function != csk_act_open_retry_timer) {
csk->retry_timer.function = csk_act_open_retry_timer;
mod_timer(&csk->retry_timer, jiffies + HZ / 2);
} else
cxgbi_sock_fail_act_open(csk,
act_open_rpl_status_to_errno(status));
spin_unlock_bh(&csk->lock);
cxgbi_sock_put(csk);
rel_skb:
__kfree_skb(skb);
}
static void do_peer_close(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_peer_close *req = (struct cpl_peer_close *)skb->data;
unsigned int tid = GET_TID(req);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find connection for tid %u.\n", tid);
goto rel_skb;
}
pr_info_ipaddr("csk 0x%p,%u,0x%lx,%u.\n",
(&csk->saddr), (&csk->daddr),
csk, csk->state, csk->flags, csk->tid);
cxgbi_sock_rcv_peer_close(csk);
rel_skb:
__kfree_skb(skb);
}
static void do_close_con_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_close_con_rpl *rpl = (struct cpl_close_con_rpl *)skb->data;
unsigned int tid = GET_TID(rpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find connection for tid %u.\n", tid);
goto rel_skb;
}
pr_info_ipaddr("csk 0x%p,%u,0x%lx,%u.\n",
(&csk->saddr), (&csk->daddr),
csk, csk->state, csk->flags, csk->tid);
cxgbi_sock_rcv_close_conn_rpl(csk, ntohl(rpl->snd_nxt));
rel_skb:
__kfree_skb(skb);
}
static int abort_status_to_errno(struct cxgbi_sock *csk, int abort_reason,
int *need_rst)
{
switch (abort_reason) {
case CPL_ERR_BAD_SYN: /* fall through */
case CPL_ERR_CONN_RESET:
return csk->state > CTP_ESTABLISHED ?
-EPIPE : -ECONNRESET;
case CPL_ERR_XMIT_TIMEDOUT:
case CPL_ERR_PERSIST_TIMEDOUT:
case CPL_ERR_FINWAIT2_TIMEDOUT:
case CPL_ERR_KEEPALIVE_TIMEDOUT:
return -ETIMEDOUT;
default:
return -EIO;
}
}
static void do_abort_req_rss(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_abort_req_rss *req = (struct cpl_abort_req_rss *)skb->data;
unsigned int tid = GET_TID(req);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
int rst_status = CPL_ABORT_NO_RST;
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find connection for tid %u.\n", tid);
goto rel_skb;
}
pr_info_ipaddr("csk 0x%p,%u,0x%lx,%u, status %u.\n",
(&csk->saddr), (&csk->daddr),
csk, csk->state, csk->flags, csk->tid, req->status);
if (is_neg_adv(req->status))
goto rel_skb;
cxgbi_sock_get(csk);
spin_lock_bh(&csk->lock);
cxgbi_sock_clear_flag(csk, CTPF_ABORT_REQ_RCVD);
if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT)) {
send_tx_flowc_wr(csk);
cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);
}
cxgbi_sock_set_flag(csk, CTPF_ABORT_REQ_RCVD);
cxgbi_sock_set_state(csk, CTP_ABORTING);
send_abort_rpl(csk, rst_status);
if (!cxgbi_sock_flag(csk, CTPF_ABORT_RPL_PENDING)) {
csk->err = abort_status_to_errno(csk, req->status, &rst_status);
cxgbi_sock_closed(csk);
}
spin_unlock_bh(&csk->lock);
cxgbi_sock_put(csk);
rel_skb:
__kfree_skb(skb);
}
static void do_abort_rpl_rss(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_abort_rpl_rss *rpl = (struct cpl_abort_rpl_rss *)skb->data;
unsigned int tid = GET_TID(rpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (!csk)
goto rel_skb;
if (csk)
pr_info_ipaddr("csk 0x%p,%u,0x%lx,%u, status %u.\n",
(&csk->saddr), (&csk->daddr), csk,
csk->state, csk->flags, csk->tid, rpl->status);
if (rpl->status == CPL_ERR_ABORT_FAILED)
goto rel_skb;
cxgbi_sock_rcv_abort_rpl(csk);
rel_skb:
__kfree_skb(skb);
}
static void do_rx_data(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_rx_data *cpl = (struct cpl_rx_data *)skb->data;
unsigned int tid = GET_TID(cpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (!csk) {
pr_err("can't find connection for tid %u.\n", tid);
} else {
/* not expecting this, reset the connection. */
pr_err("csk 0x%p, tid %u, rcv cpl_rx_data.\n", csk, tid);
spin_lock_bh(&csk->lock);
send_abort_req(csk);
spin_unlock_bh(&csk->lock);
}
__kfree_skb(skb);
}
static void do_rx_iscsi_hdr(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_iscsi_hdr *cpl = (struct cpl_iscsi_hdr *)skb->data;
unsigned short pdu_len_ddp = be16_to_cpu(cpl->pdu_len_ddp);
unsigned int tid = GET_TID(cpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find conn. for tid %u.\n", tid);
goto rel_skb;
}
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, tid %u, skb 0x%p,%u, 0x%x.\n",
csk, csk->state, csk->flags, csk->tid, skb, skb->len,
pdu_len_ddp);
spin_lock_bh(&csk->lock);
if (unlikely(csk->state >= CTP_PASSIVE_CLOSE)) {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, bad state.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->state != CTP_ABORTING)
goto abort_conn;
else
goto discard;
}
cxgbi_skcb_tcp_seq(skb) = ntohl(cpl->seq);
cxgbi_skcb_flags(skb) = 0;
skb_reset_transport_header(skb);
__skb_pull(skb, sizeof(*cpl));
__pskb_trim(skb, ntohs(cpl->len));
if (!csk->skb_ulp_lhdr) {
unsigned char *bhs;
unsigned int hlen, dlen, plen;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, tid %u, skb 0x%p header.\n",
csk, csk->state, csk->flags, csk->tid, skb);
csk->skb_ulp_lhdr = skb;
cxgbi_skcb_set_flag(skb, SKCBF_RX_HDR);
if (cxgbi_skcb_tcp_seq(skb) != csk->rcv_nxt) {
pr_info("tid %u, CPL_ISCSI_HDR, bad seq, 0x%x/0x%x.\n",
csk->tid, cxgbi_skcb_tcp_seq(skb),
csk->rcv_nxt);
goto abort_conn;
}
bhs = skb->data;
hlen = ntohs(cpl->len);
dlen = ntohl(*(unsigned int *)(bhs + 4)) & 0xFFFFFF;
plen = ISCSI_PDU_LEN_G(pdu_len_ddp);
if (is_t4(lldi->adapter_type))
plen -= 40;
if ((hlen + dlen) != plen) {
pr_info("tid 0x%x, CPL_ISCSI_HDR, pdu len "
"mismatch %u != %u + %u, seq 0x%x.\n",
csk->tid, plen, hlen, dlen,
cxgbi_skcb_tcp_seq(skb));
goto abort_conn;
}
cxgbi_skcb_rx_pdulen(skb) = (hlen + dlen + 3) & (~0x3);
if (dlen)
cxgbi_skcb_rx_pdulen(skb) += csk->dcrc_len;
csk->rcv_nxt += cxgbi_skcb_rx_pdulen(skb);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p, skb 0x%p, 0x%x,%u+%u,0x%x,0x%x.\n",
csk, skb, *bhs, hlen, dlen,
ntohl(*((unsigned int *)(bhs + 16))),
ntohl(*((unsigned int *)(bhs + 24))));
} else {
struct sk_buff *lskb = csk->skb_ulp_lhdr;
cxgbi_skcb_set_flag(lskb, SKCBF_RX_DATA);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, skb 0x%p data, 0x%p.\n",
csk, csk->state, csk->flags, skb, lskb);
}
__skb_queue_tail(&csk->receive_queue, skb);
spin_unlock_bh(&csk->lock);
return;
abort_conn:
send_abort_req(csk);
discard:
spin_unlock_bh(&csk->lock);
rel_skb:
__kfree_skb(skb);
}
static void do_rx_iscsi_data(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_iscsi_hdr *cpl = (struct cpl_iscsi_hdr *)skb->data;
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
struct sk_buff *lskb;
u32 tid = GET_TID(cpl);
u16 pdu_len_ddp = be16_to_cpu(cpl->pdu_len_ddp);
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find conn. for tid %u.\n", tid);
goto rel_skb;
}
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, tid %u, skb 0x%p,%u, 0x%x.\n",
csk, csk->state, csk->flags, csk->tid, skb,
skb->len, pdu_len_ddp);
spin_lock_bh(&csk->lock);
if (unlikely(csk->state >= CTP_PASSIVE_CLOSE)) {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, bad state.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->state != CTP_ABORTING)
goto abort_conn;
else
goto discard;
}
cxgbi_skcb_tcp_seq(skb) = be32_to_cpu(cpl->seq);
cxgbi_skcb_flags(skb) = 0;
skb_reset_transport_header(skb);
__skb_pull(skb, sizeof(*cpl));
__pskb_trim(skb, ntohs(cpl->len));
if (!csk->skb_ulp_lhdr)
csk->skb_ulp_lhdr = skb;
lskb = csk->skb_ulp_lhdr;
cxgbi_skcb_set_flag(lskb, SKCBF_RX_DATA);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, skb 0x%p data, 0x%p.\n",
csk, csk->state, csk->flags, skb, lskb);
__skb_queue_tail(&csk->receive_queue, skb);
spin_unlock_bh(&csk->lock);
return;
abort_conn:
send_abort_req(csk);
discard:
spin_unlock_bh(&csk->lock);
rel_skb:
__kfree_skb(skb);
}
static void
cxgb4i_process_ddpvld(struct cxgbi_sock *csk,
struct sk_buff *skb, u32 ddpvld)
{
if (ddpvld & (1 << CPL_RX_DDP_STATUS_HCRC_SHIFT)) {
pr_info("csk 0x%p, lhdr 0x%p, status 0x%x, hcrc bad 0x%lx.\n",
csk, skb, ddpvld, cxgbi_skcb_flags(skb));
cxgbi_skcb_set_flag(skb, SKCBF_RX_HCRC_ERR);
}
if (ddpvld & (1 << CPL_RX_DDP_STATUS_DCRC_SHIFT)) {
pr_info("csk 0x%p, lhdr 0x%p, status 0x%x, dcrc bad 0x%lx.\n",
csk, skb, ddpvld, cxgbi_skcb_flags(skb));
cxgbi_skcb_set_flag(skb, SKCBF_RX_DCRC_ERR);
}
if (ddpvld & (1 << CPL_RX_DDP_STATUS_PAD_SHIFT)) {
log_debug(1 << CXGBI_DBG_PDU_RX,
"csk 0x%p, lhdr 0x%p, status 0x%x, pad bad.\n",
csk, skb, ddpvld);
cxgbi_skcb_set_flag(skb, SKCBF_RX_PAD_ERR);
}
if ((ddpvld & (1 << CPL_RX_DDP_STATUS_DDP_SHIFT)) &&
!cxgbi_skcb_test_flag(skb, SKCBF_RX_DATA)) {
log_debug(1 << CXGBI_DBG_PDU_RX,
"csk 0x%p, lhdr 0x%p, 0x%x, data ddp'ed.\n",
csk, skb, ddpvld);
cxgbi_skcb_set_flag(skb, SKCBF_RX_DATA_DDPD);
}
}
static void do_rx_data_ddp(struct cxgbi_device *cdev,
struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct sk_buff *lskb;
struct cpl_rx_data_ddp *rpl = (struct cpl_rx_data_ddp *)skb->data;
unsigned int tid = GET_TID(rpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
u32 ddpvld = be32_to_cpu(rpl->ddpvld);
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find connection for tid %u.\n", tid);
goto rel_skb;
}
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, skb 0x%p,0x%x, lhdr 0x%p.\n",
csk, csk->state, csk->flags, skb, ddpvld, csk->skb_ulp_lhdr);
spin_lock_bh(&csk->lock);
if (unlikely(csk->state >= CTP_PASSIVE_CLOSE)) {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, bad state.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->state != CTP_ABORTING)
goto abort_conn;
else
goto discard;
}
if (!csk->skb_ulp_lhdr) {
pr_err("tid 0x%x, rcv RX_DATA_DDP w/o pdu bhs.\n", csk->tid);
goto abort_conn;
}
lskb = csk->skb_ulp_lhdr;
csk->skb_ulp_lhdr = NULL;
cxgbi_skcb_rx_ddigest(lskb) = ntohl(rpl->ulp_crc);
if (ntohs(rpl->len) != cxgbi_skcb_rx_pdulen(lskb))
pr_info("tid 0x%x, RX_DATA_DDP pdulen %u != %u.\n",
csk->tid, ntohs(rpl->len), cxgbi_skcb_rx_pdulen(lskb));
cxgb4i_process_ddpvld(csk, lskb, ddpvld);
log_debug(1 << CXGBI_DBG_PDU_RX,
"csk 0x%p, lskb 0x%p, f 0x%lx.\n",
csk, lskb, cxgbi_skcb_flags(lskb));
cxgbi_skcb_set_flag(lskb, SKCBF_RX_STATUS);
cxgbi_conn_pdu_ready(csk);
spin_unlock_bh(&csk->lock);
goto rel_skb;
abort_conn:
send_abort_req(csk);
discard:
spin_unlock_bh(&csk->lock);
rel_skb:
__kfree_skb(skb);
}
static void
do_rx_iscsi_cmp(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_rx_iscsi_cmp *rpl = (struct cpl_rx_iscsi_cmp *)skb->data;
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
struct sk_buff *data_skb = NULL;
u32 tid = GET_TID(rpl);
u32 ddpvld = be32_to_cpu(rpl->ddpvld);
u32 seq = be32_to_cpu(rpl->seq);
u16 pdu_len_ddp = be16_to_cpu(rpl->pdu_len_ddp);
csk = lookup_tid(t, tid);
if (unlikely(!csk)) {
pr_err("can't find connection for tid %u.\n", tid);
goto rel_skb;
}
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_PDU_RX,
"csk 0x%p,%u,0x%lx, skb 0x%p,0x%x, lhdr 0x%p, len %u, "
"pdu_len_ddp %u, status %u.\n",
csk, csk->state, csk->flags, skb, ddpvld, csk->skb_ulp_lhdr,
ntohs(rpl->len), pdu_len_ddp, rpl->status);
spin_lock_bh(&csk->lock);
if (unlikely(csk->state >= CTP_PASSIVE_CLOSE)) {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u, bad state.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->state != CTP_ABORTING)
goto abort_conn;
else
goto discard;
}
cxgbi_skcb_tcp_seq(skb) = seq;
cxgbi_skcb_flags(skb) = 0;
cxgbi_skcb_rx_pdulen(skb) = 0;
skb_reset_transport_header(skb);
__skb_pull(skb, sizeof(*rpl));
__pskb_trim(skb, be16_to_cpu(rpl->len));
csk->rcv_nxt = seq + pdu_len_ddp;
if (csk->skb_ulp_lhdr) {
data_skb = skb_peek(&csk->receive_queue);
if (!data_skb ||
!cxgbi_skcb_test_flag(data_skb, SKCBF_RX_DATA)) {
pr_err("Error! freelist data not found 0x%p, tid %u\n",
data_skb, tid);
goto abort_conn;
}
__skb_unlink(data_skb, &csk->receive_queue);
cxgbi_skcb_set_flag(skb, SKCBF_RX_DATA);
__skb_queue_tail(&csk->receive_queue, skb);
__skb_queue_tail(&csk->receive_queue, data_skb);
} else {
__skb_queue_tail(&csk->receive_queue, skb);
}
csk->skb_ulp_lhdr = NULL;
cxgbi_skcb_set_flag(skb, SKCBF_RX_HDR);
cxgbi_skcb_set_flag(skb, SKCBF_RX_STATUS);
cxgbi_skcb_set_flag(skb, SKCBF_RX_ISCSI_COMPL);
cxgbi_skcb_rx_ddigest(skb) = be32_to_cpu(rpl->ulp_crc);
cxgb4i_process_ddpvld(csk, skb, ddpvld);
log_debug(1 << CXGBI_DBG_PDU_RX, "csk 0x%p, skb 0x%p, f 0x%lx.\n",
csk, skb, cxgbi_skcb_flags(skb));
cxgbi_conn_pdu_ready(csk);
spin_unlock_bh(&csk->lock);
return;
abort_conn:
send_abort_req(csk);
discard:
spin_unlock_bh(&csk->lock);
rel_skb:
__kfree_skb(skb);
}
static void do_fw4_ack(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cxgbi_sock *csk;
struct cpl_fw4_ack *rpl = (struct cpl_fw4_ack *)skb->data;
unsigned int tid = GET_TID(rpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
csk = lookup_tid(t, tid);
if (unlikely(!csk))
pr_err("can't find connection for tid %u.\n", tid);
else {
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u.\n",
csk, csk->state, csk->flags, csk->tid);
cxgbi_sock_rcv_wr_ack(csk, rpl->credits, ntohl(rpl->snd_una),
rpl->seq_vld);
}
__kfree_skb(skb);
}
static void do_set_tcb_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
{
struct cpl_set_tcb_rpl *rpl = (struct cpl_set_tcb_rpl *)skb->data;
unsigned int tid = GET_TID(rpl);
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct tid_info *t = lldi->tids;
struct cxgbi_sock *csk;
csk = lookup_tid(t, tid);
if (!csk)
pr_err("can't find conn. for tid %u.\n", tid);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,%lx,%u, status 0x%x.\n",
csk, csk->state, csk->flags, csk->tid, rpl->status);
if (rpl->status != CPL_ERR_NONE)
pr_err("csk 0x%p,%u, SET_TCB_RPL status %u.\n",
csk, tid, rpl->status);
__kfree_skb(skb);
}
static int alloc_cpls(struct cxgbi_sock *csk)
{
csk->cpl_close = alloc_wr(sizeof(struct cpl_close_con_req),
0, GFP_KERNEL);
if (!csk->cpl_close)
return -ENOMEM;
csk->cpl_abort_req = alloc_wr(sizeof(struct cpl_abort_req),
0, GFP_KERNEL);
if (!csk->cpl_abort_req)
goto free_cpls;
csk->cpl_abort_rpl = alloc_wr(sizeof(struct cpl_abort_rpl),
0, GFP_KERNEL);
if (!csk->cpl_abort_rpl)
goto free_cpls;
return 0;
free_cpls:
cxgbi_sock_free_cpl_skbs(csk);
return -ENOMEM;
}
static inline void l2t_put(struct cxgbi_sock *csk)
{
if (csk->l2t) {
cxgb4_l2t_release(csk->l2t);
csk->l2t = NULL;
cxgbi_sock_put(csk);
}
}
static void release_offload_resources(struct cxgbi_sock *csk)
{
struct cxgb4_lld_info *lldi;
#if IS_ENABLED(CONFIG_IPV6)
struct net_device *ndev = csk->cdev->ports[csk->port_id];
#endif
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u.\n",
csk, csk->state, csk->flags, csk->tid);
cxgbi_sock_free_cpl_skbs(csk);
cxgbi_sock_purge_write_queue(csk);
if (csk->wr_cred != csk->wr_max_cred) {
cxgbi_sock_purge_wr_queue(csk);
cxgbi_sock_reset_wr_list(csk);
}
l2t_put(csk);
#if IS_ENABLED(CONFIG_IPV6)
if (csk->csk_family == AF_INET6)
cxgb4_clip_release(ndev,
(const u32 *)&csk->saddr6.sin6_addr, 1);
#endif
if (cxgbi_sock_flag(csk, CTPF_HAS_ATID))
free_atid(csk);
else if (cxgbi_sock_flag(csk, CTPF_HAS_TID)) {
lldi = cxgbi_cdev_priv(csk->cdev);
cxgb4_remove_tid(lldi->tids, 0, csk->tid,
csk->csk_family);
cxgbi_sock_clear_flag(csk, CTPF_HAS_TID);
cxgbi_sock_put(csk);
}
csk->dst = NULL;
}
static int init_act_open(struct cxgbi_sock *csk)
{
struct cxgbi_device *cdev = csk->cdev;
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct net_device *ndev = cdev->ports[csk->port_id];
struct sk_buff *skb = NULL;
struct neighbour *n = NULL;
void *daddr;
unsigned int step;
unsigned int rxq_idx;
unsigned int size, size6;
unsigned int linkspeed;
unsigned int rcv_winf, snd_winf;
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p,%u,0x%lx,%u.\n",
csk, csk->state, csk->flags, csk->tid);
if (csk->csk_family == AF_INET)
daddr = &csk->daddr.sin_addr.s_addr;
#if IS_ENABLED(CONFIG_IPV6)
else if (csk->csk_family == AF_INET6)
daddr = &csk->daddr6.sin6_addr;
#endif
else {
pr_err("address family 0x%x not supported\n", csk->csk_family);
goto rel_resource;
}
n = dst_neigh_lookup(csk->dst, daddr);
if (!n) {
pr_err("%s, can't get neighbour of csk->dst.\n", ndev->name);
goto rel_resource;
}
if (!(n->nud_state & NUD_VALID))
neigh_event_send(n, NULL);
csk->atid = cxgb4_alloc_atid(lldi->tids, csk);
if (csk->atid < 0) {
pr_err("%s, NO atid available.\n", ndev->name);
goto rel_resource_without_clip;
}
cxgbi_sock_set_flag(csk, CTPF_HAS_ATID);
cxgbi_sock_get(csk);
csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);
if (!csk->l2t) {
pr_err("%s, cannot alloc l2t.\n", ndev->name);
goto rel_resource_without_clip;
}
cxgbi_sock_get(csk);
#if IS_ENABLED(CONFIG_IPV6)
if (csk->csk_family == AF_INET6)
cxgb4_clip_get(ndev, (const u32 *)&csk->saddr6.sin6_addr, 1);
#endif
if (is_t4(lldi->adapter_type)) {
size = sizeof(struct cpl_act_open_req);
size6 = sizeof(struct cpl_act_open_req6);
} else if (is_t5(lldi->adapter_type)) {
size = sizeof(struct cpl_t5_act_open_req);
size6 = sizeof(struct cpl_t5_act_open_req6);
} else {
size = sizeof(struct cpl_t6_act_open_req);
size6 = sizeof(struct cpl_t6_act_open_req6);
}
if (csk->csk_family == AF_INET)
skb = alloc_wr(size, 0, GFP_NOIO);
#if IS_ENABLED(CONFIG_IPV6)
else
skb = alloc_wr(size6, 0, GFP_NOIO);
#endif
if (!skb)
goto rel_resource;
skb->sk = (struct sock *)csk;
t4_set_arp_err_handler(skb, csk, cxgbi_sock_act_open_req_arp_failure);
if (!csk->mtu)
csk->mtu = dst_mtu(csk->dst);
cxgb4_best_mtu(lldi->mtus, csk->mtu, &csk->mss_idx);
csk->tx_chan = cxgb4_port_chan(ndev);
csk->smac_idx = cxgb4_tp_smt_idx(lldi->adapter_type,
cxgb4_port_viid(ndev));
step = lldi->ntxq / lldi->nchan;
csk->txq_idx = cxgb4_port_idx(ndev) * step;
step = lldi->nrxq / lldi->nchan;
rxq_idx = (cxgb4_port_idx(ndev) * step) + (cdev->rxq_idx_cntr % step);
cdev->rxq_idx_cntr++;
csk->rss_qid = lldi->rxq_ids[rxq_idx];
linkspeed = ((struct port_info *)netdev_priv(ndev))->link_cfg.speed;
csk->snd_win = cxgb4i_snd_win;
csk->rcv_win = cxgb4i_rcv_win;
if (cxgb4i_rcv_win <= 0) {
csk->rcv_win = CXGB4I_DEFAULT_10G_RCV_WIN;
rcv_winf = linkspeed / SPEED_10000;
if (rcv_winf)
csk->rcv_win *= rcv_winf;
}
if (cxgb4i_snd_win <= 0) {
csk->snd_win = CXGB4I_DEFAULT_10G_SND_WIN;
snd_winf = linkspeed / SPEED_10000;
if (snd_winf)
csk->snd_win *= snd_winf;
}
csk->wr_cred = lldi->wr_cred -
DIV_ROUND_UP(sizeof(struct cpl_abort_req), 16);
csk->wr_max_cred = csk->wr_cred;
csk->wr_una_cred = 0;
cxgbi_sock_reset_wr_list(csk);
csk->err = 0;
pr_info_ipaddr("csk 0x%p,%u,0x%lx,%u,%u,%u, mtu %u,%u, smac %u.\n",
(&csk->saddr), (&csk->daddr), csk, csk->state,
csk->flags, csk->tx_chan, csk->txq_idx, csk->rss_qid,
csk->mtu, csk->mss_idx, csk->smac_idx);
/* must wait for either a act_open_rpl or act_open_establish */
if (!try_module_get(cdev->owner)) {
pr_err("%s, try_module_get failed.\n", ndev->name);
goto rel_resource;
}
cxgbi_sock_set_state(csk, CTP_ACTIVE_OPEN);
if (csk->csk_family == AF_INET)
send_act_open_req(csk, skb, csk->l2t);
#if IS_ENABLED(CONFIG_IPV6)
else
send_act_open_req6(csk, skb, csk->l2t);
#endif
neigh_release(n);
return 0;
rel_resource:
#if IS_ENABLED(CONFIG_IPV6)
if (csk->csk_family == AF_INET6)
cxgb4_clip_release(ndev,
(const u32 *)&csk->saddr6.sin6_addr, 1);
#endif
rel_resource_without_clip:
if (n)
neigh_release(n);
if (skb)
__kfree_skb(skb);
return -EINVAL;
}
static cxgb4i_cplhandler_func cxgb4i_cplhandlers[NUM_CPL_CMDS] = {
[CPL_ACT_ESTABLISH] = do_act_establish,
[CPL_ACT_OPEN_RPL] = do_act_open_rpl,
[CPL_PEER_CLOSE] = do_peer_close,
[CPL_ABORT_REQ_RSS] = do_abort_req_rss,
[CPL_ABORT_RPL_RSS] = do_abort_rpl_rss,
[CPL_CLOSE_CON_RPL] = do_close_con_rpl,
[CPL_FW4_ACK] = do_fw4_ack,
[CPL_ISCSI_HDR] = do_rx_iscsi_hdr,
[CPL_ISCSI_DATA] = do_rx_iscsi_data,
[CPL_SET_TCB_RPL] = do_set_tcb_rpl,
[CPL_RX_DATA_DDP] = do_rx_data_ddp,
[CPL_RX_ISCSI_DDP] = do_rx_data_ddp,
[CPL_RX_ISCSI_CMP] = do_rx_iscsi_cmp,
[CPL_RX_DATA] = do_rx_data,
};
static int cxgb4i_ofld_init(struct cxgbi_device *cdev)
{
int rc;
if (cxgb4i_max_connect > CXGB4I_MAX_CONN)
cxgb4i_max_connect = CXGB4I_MAX_CONN;
rc = cxgbi_device_portmap_create(cdev, cxgb4i_sport_base,
cxgb4i_max_connect);
if (rc < 0)
return rc;
cdev->csk_release_offload_resources = release_offload_resources;
cdev->csk_push_tx_frames = push_tx_frames;
cdev->csk_send_abort_req = send_abort_req;
cdev->csk_send_close_req = send_close_req;
cdev->csk_send_rx_credits = send_rx_credits;
cdev->csk_alloc_cpls = alloc_cpls;
cdev->csk_init_act_open = init_act_open;
pr_info("cdev 0x%p, offload up, added.\n", cdev);
return 0;
}
static inline void
ulp_mem_io_set_hdr(struct cxgbi_device *cdev,
struct ulp_mem_io *req,
unsigned int wr_len, unsigned int dlen,
unsigned int pm_addr,
int tid)
{
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct ulptx_idata *idata = (struct ulptx_idata *)(req + 1);
INIT_ULPTX_WR(req, wr_len, 0, tid);
req->wr.wr_hi = htonl(FW_WR_OP_V(FW_ULPTX_WR) |
FW_WR_ATOMIC_V(0));
req->cmd = htonl(ULPTX_CMD_V(ULP_TX_MEM_WRITE) |
ULP_MEMIO_ORDER_V(is_t4(lldi->adapter_type)) |
T5_ULP_MEMIO_IMM_V(!is_t4(lldi->adapter_type)));
req->dlen = htonl(ULP_MEMIO_DATA_LEN_V(dlen >> 5));
req->lock_addr = htonl(ULP_MEMIO_ADDR_V(pm_addr >> 5));
req->len16 = htonl(DIV_ROUND_UP(wr_len - sizeof(req->wr), 16));
idata->cmd_more = htonl(ULPTX_CMD_V(ULP_TX_SC_IMM));
idata->len = htonl(dlen);
}
static struct sk_buff *
ddp_ppod_init_idata(struct cxgbi_device *cdev,
struct cxgbi_ppm *ppm,
unsigned int idx, unsigned int npods,
unsigned int tid)
{
unsigned int pm_addr = (idx << PPOD_SIZE_SHIFT) + ppm->llimit;
unsigned int dlen = npods << PPOD_SIZE_SHIFT;
unsigned int wr_len = roundup(sizeof(struct ulp_mem_io) +
sizeof(struct ulptx_idata) + dlen, 16);
struct sk_buff *skb = alloc_wr(wr_len, 0, GFP_ATOMIC);
if (!skb) {
pr_err("%s: %s idx %u, npods %u, OOM.\n",
__func__, ppm->ndev->name, idx, npods);
return NULL;
}
ulp_mem_io_set_hdr(cdev, (struct ulp_mem_io *)skb->head, wr_len, dlen,
pm_addr, tid);
return skb;
}
static int ddp_ppod_write_idata(struct cxgbi_ppm *ppm, struct cxgbi_sock *csk,
struct cxgbi_task_tag_info *ttinfo,
unsigned int idx, unsigned int npods,
struct scatterlist **sg_pp,
unsigned int *sg_off)
{
struct cxgbi_device *cdev = csk->cdev;
struct sk_buff *skb = ddp_ppod_init_idata(cdev, ppm, idx, npods,
csk->tid);
struct ulp_mem_io *req;
struct ulptx_idata *idata;
struct cxgbi_pagepod *ppod;
int i;
if (!skb)
return -ENOMEM;
req = (struct ulp_mem_io *)skb->head;
idata = (struct ulptx_idata *)(req + 1);
ppod = (struct cxgbi_pagepod *)(idata + 1);
for (i = 0; i < npods; i++, ppod++)
cxgbi_ddp_set_one_ppod(ppod, ttinfo, sg_pp, sg_off);
cxgbi_skcb_set_flag(skb, SKCBF_TX_MEM_WRITE);
cxgbi_skcb_set_flag(skb, SKCBF_TX_FLAG_COMPL);
set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
spin_lock_bh(&csk->lock);
cxgbi_sock_skb_entail(csk, skb);
spin_unlock_bh(&csk->lock);
return 0;
}
static int ddp_set_map(struct cxgbi_ppm *ppm, struct cxgbi_sock *csk,
struct cxgbi_task_tag_info *ttinfo)
{
unsigned int pidx = ttinfo->idx;
unsigned int npods = ttinfo->npods;
unsigned int i, cnt;
int err = 0;
struct scatterlist *sg = ttinfo->sgl;
unsigned int offset = 0;
ttinfo->cid = csk->port_id;
for (i = 0; i < npods; i += cnt, pidx += cnt) {
cnt = npods - i;
if (cnt > ULPMEM_IDATA_MAX_NPPODS)
cnt = ULPMEM_IDATA_MAX_NPPODS;
err = ddp_ppod_write_idata(ppm, csk, ttinfo, pidx, cnt,
&sg, &offset);
if (err < 0)
break;
}
return err;
}
static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
int pg_idx, bool reply)
{
struct sk_buff *skb;
struct cpl_set_tcb_field *req;
if (!pg_idx || pg_idx >= DDP_PGIDX_MAX)
return 0;
skb = alloc_wr(sizeof(*req), 0, GFP_KERNEL);
if (!skb)
return -ENOMEM;
/* set up ulp page size */
req = (struct cpl_set_tcb_field *)skb->head;
INIT_TP_WR(req, csk->tid);
OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, csk->tid));
req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
req->word_cookie = htons(0);
req->mask = cpu_to_be64(0x3 << 8);
req->val = cpu_to_be64(pg_idx << 8);
set_wr_txq(skb, CPL_PRIORITY_CONTROL, csk->port_id);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p, tid 0x%x, pg_idx %u.\n", csk, csk->tid, pg_idx);
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
return 0;
}
static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
int hcrc, int dcrc, int reply)
{
struct sk_buff *skb;
struct cpl_set_tcb_field *req;
if (!hcrc && !dcrc)
return 0;
skb = alloc_wr(sizeof(*req), 0, GFP_KERNEL);
if (!skb)
return -ENOMEM;
csk->hcrc_len = (hcrc ? 4 : 0);
csk->dcrc_len = (dcrc ? 4 : 0);
/* set up ulp submode */
req = (struct cpl_set_tcb_field *)skb->head;
INIT_TP_WR(req, tid);
OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
req->word_cookie = htons(0);
req->mask = cpu_to_be64(0x3 << 4);
req->val = cpu_to_be64(((hcrc ? ULP_CRC_HEADER : 0) |
(dcrc ? ULP_CRC_DATA : 0)) << 4);
set_wr_txq(skb, CPL_PRIORITY_CONTROL, csk->port_id);
log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
"csk 0x%p, tid 0x%x, crc %d,%d.\n", csk, csk->tid, hcrc, dcrc);
cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
return 0;
}
static struct cxgbi_ppm *cdev2ppm(struct cxgbi_device *cdev)
{
return (struct cxgbi_ppm *)(*((struct cxgb4_lld_info *)
(cxgbi_cdev_priv(cdev)))->iscsi_ppm);
}
static int cxgb4i_ddp_init(struct cxgbi_device *cdev)
{
struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
struct net_device *ndev = cdev->ports[0];
struct cxgbi_tag_format tformat;
unsigned int ppmax;
int i;
if (!lldi->vr->iscsi.size) {
pr_warn("%s, iscsi NOT enabled, check config!\n", ndev->name);
return -EACCES;
}
cdev->flags |= CXGBI_FLAG_USE_PPOD_OFLDQ;
ppmax = lldi->vr->iscsi.size >> PPOD_SIZE_SHIFT;
memset(&tformat, 0, sizeof(struct cxgbi_tag_format));
for (i = 0; i < 4; i++)
tformat.pgsz_order[i] = (lldi->iscsi_pgsz_order >> (i << 3))
& 0xF;
cxgbi_tagmask_check(lldi->iscsi_tagmask, &tformat);
cxgbi_ddp_ppm_setup(lldi->iscsi_ppm, cdev, &tformat, ppmax,
lldi->iscsi_llimit, lldi->vr->iscsi.start, 2);
cdev->csk_ddp_setup_digest = ddp_setup_conn_digest;
cdev->csk_ddp_setup_pgidx = ddp_setup_conn_pgidx;
cdev->csk_ddp_set_map = ddp_set_map;
cdev->tx_max_size = min_t(unsigned int, ULP2_MAX_PDU_PAYLOAD,
lldi->iscsi_iolen - ISCSI_PDU_NONPAYLOAD_LEN);
cdev->rx_max_size = min_t(unsigned int, ULP2_MAX_PDU_PAYLOAD,
lldi->iscsi_iolen - ISCSI_PDU_NONPAYLOAD_LEN);
cdev->cdev2ppm = cdev2ppm;
return 0;
}
static void *t4_uld_add(const struct cxgb4_lld_info *lldi)
{
struct cxgbi_device *cdev;
struct port_info *pi;
int i, rc;
cdev = cxgbi_device_register(sizeof(*lldi), lldi->nports);
if (!cdev) {
pr_info("t4 device 0x%p, register failed.\n", lldi);
return NULL;
}
pr_info("0x%p,0x%x, ports %u,%s, chan %u, q %u,%u, wr %u.\n",
cdev, lldi->adapter_type, lldi->nports,
lldi->ports[0]->name, lldi->nchan, lldi->ntxq,
lldi->nrxq, lldi->wr_cred);
for (i = 0; i < lldi->nrxq; i++)
log_debug(1 << CXGBI_DBG_DEV,
"t4 0x%p, rxq id #%d: %u.\n",
cdev, i, lldi->rxq_ids[i]);
memcpy(cxgbi_cdev_priv(cdev), lldi, sizeof(*lldi));
cdev->flags = CXGBI_FLAG_DEV_T4;
cdev->pdev = lldi->pdev;
cdev->ports = lldi->ports;
cdev->nports = lldi->nports;
cdev->mtus = lldi->mtus;
cdev->nmtus = NMTUS;
cdev->rx_credit_thres = (CHELSIO_CHIP_VERSION(lldi->adapter_type) <=
CHELSIO_T5) ? cxgb4i_rx_credit_thres : 0;
cdev->skb_tx_rsvd = CXGB4I_TX_HEADER_LEN;
cdev->skb_rx_extra = sizeof(struct cpl_iscsi_hdr);
cdev->itp = &cxgb4i_iscsi_transport;
cdev->owner = THIS_MODULE;
cdev->pfvf = FW_VIID_PFN_G(cxgb4_port_viid(lldi->ports[0]))
<< FW_VIID_PFN_S;
pr_info("cdev 0x%p,%s, pfvf %u.\n",
cdev, lldi->ports[0]->name, cdev->pfvf);
rc = cxgb4i_ddp_init(cdev);
if (rc) {
pr_info("t4 0x%p ddp init failed.\n", cdev);
goto err_out;
}
rc = cxgb4i_ofld_init(cdev);
if (rc) {
pr_info("t4 0x%p ofld init failed.\n", cdev);
goto err_out;
}
rc = cxgbi_hbas_add(cdev, CXGB4I_MAX_LUN, CXGBI_MAX_CONN,
&cxgb4i_host_template, cxgb4i_stt);
if (rc)
goto err_out;
for (i = 0; i < cdev->nports; i++) {
pi = netdev_priv(lldi->ports[i]);
cdev->hbas[i]->port_id = pi->port_id;
}
return cdev;
err_out:
cxgbi_device_unregister(cdev);
return ERR_PTR(-ENOMEM);
}
#define RX_PULL_LEN 128
static int t4_uld_rx_handler(void *handle, const __be64 *rsp,
const struct pkt_gl *pgl)
{
const struct cpl_act_establish *rpl;
struct sk_buff *skb;
unsigned int opc;
struct cxgbi_device *cdev = handle;
if (pgl == NULL) {
unsigned int len = 64 - sizeof(struct rsp_ctrl) - 8;
skb = alloc_wr(len, 0, GFP_ATOMIC);
if (!skb)
goto nomem;
skb_copy_to_linear_data(skb, &rsp[1], len);
} else {
if (unlikely(*(u8 *)rsp != *(u8 *)pgl->va)) {
pr_info("? FL 0x%p,RSS%#llx,FL %#llx,len %u.\n",
pgl->va, be64_to_cpu(*rsp),
be64_to_cpu(*(u64 *)pgl->va),
pgl->tot_len);
return 0;
}
skb = cxgb4_pktgl_to_skb(pgl, RX_PULL_LEN, RX_PULL_LEN);
if (unlikely(!skb))
goto nomem;
}
rpl = (struct cpl_act_establish *)skb->data;
opc = rpl->ot.opcode;
log_debug(1 << CXGBI_DBG_TOE,
"cdev %p, opcode 0x%x(0x%x,0x%x), skb %p.\n",
cdev, opc, rpl->ot.opcode_tid, ntohl(rpl->ot.opcode_tid), skb);
if (cxgb4i_cplhandlers[opc])
cxgb4i_cplhandlers[opc](cdev, skb);
else {
pr_err("No handler for opcode 0x%x.\n", opc);
__kfree_skb(skb);
}
return 0;
nomem:
log_debug(1 << CXGBI_DBG_TOE, "OOM bailing out.\n");
return 1;
}
static int t4_uld_state_change(void *handle, enum cxgb4_state state)
{
struct cxgbi_device *cdev = handle;
switch (state) {
case CXGB4_STATE_UP:
pr_info("cdev 0x%p, UP.\n", cdev);
break;
case CXGB4_STATE_START_RECOVERY:
pr_info("cdev 0x%p, RECOVERY.\n", cdev);
/* close all connections */
break;
case CXGB4_STATE_DOWN:
pr_info("cdev 0x%p, DOWN.\n", cdev);
break;
case CXGB4_STATE_DETACH:
pr_info("cdev 0x%p, DETACH.\n", cdev);
cxgbi_device_unregister(cdev);
break;
default:
pr_info("cdev 0x%p, unknown state %d.\n", cdev, state);
break;
}
return 0;
}
static int __init cxgb4i_init_module(void)
{
int rc;
printk(KERN_INFO "%s", version);
rc = cxgbi_iscsi_init(&cxgb4i_iscsi_transport, &cxgb4i_stt);
if (rc < 0)
return rc;
cxgb4_register_uld(CXGB4_ULD_ISCSI, &cxgb4i_uld_info);
return 0;
}
static void __exit cxgb4i_exit_module(void)
{
cxgb4_unregister_uld(CXGB4_ULD_ISCSI);
cxgbi_device_unregister_all(CXGBI_FLAG_DEV_T4);
cxgbi_iscsi_cleanup(&cxgb4i_iscsi_transport, &cxgb4i_stt);
}
module_init(cxgb4i_init_module);
module_exit(cxgb4i_exit_module);
| gpl-2.0 |
jlubawy/obd-dos | vendor/WiShield/clock-arch.h | 1607 |
/******************************************************************************
Filename: clock-arch.h
Description: Timer routine file
******************************************************************************
TCP/IP stack and driver for the WiShield 1.0 wireless devices
Copyright(c) 2009 Async Labs Inc. All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59
Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Contact Information:
<[email protected]>
Author Date Comment
---------------------------------------------------------------
AsyncLabs 05/29/2009 Initial port
*****************************************************************************/
#ifndef __CLOCK_ARCH_H__
#define __CLOCK_ARCH_H__
#include <stdint.h>
typedef uint32_t clock_time_t;
#define CLOCK_CONF_SECOND (clock_time_t)1000
//(F_CPU / (1024*255)), this cannot be used as it gives overflows
//Freqency divided prescaler and counter register size
#include "clock.h"
#endif /* __CLOCK_ARCH_H__ */
| gpl-2.0 |
wufucious/moped | squawk/cldc/src/com/sun/cldc/util/j2me/CalendarImpl.java | 30363 | /*
* Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* only, as published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is
* included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* Please contact Sun Microsystems, Inc., 16 Network Circle, Menlo
* Park, CA 94025 or visit www.sun.com if you need additional
* information or have any questions.
*/
package com.sun.cldc.util.j2me;
import java.util.*;
/**
* This class is an implementation of the subsetted
* CLDC 1.1 Calendar class.
*
* @see java.util.Calendar
* @see java.util.TimeZone
*/
public class CalendarImpl extends Calendar {
/* ERA */
private static final int BC = 0;
private static final int AD = 1;
/* January 1, year 1 (Gregorian) */
private static final int JAN_1_1_JULIAN_DAY = 1721426;
/* January 1, 1970 (Gregorian) */
private static final int EPOCH_JULIAN_DAY = 2440588;
/* 0-based, for day-in-year */
private static final int NUM_DAYS[]
= {0,31,59,90,120,151,181,212,243,273,304,334};
/* 0-based, for day-in-year */
private static final int LEAP_NUM_DAYS[]
= {0,31,60,91,121,152,182,213,244,274,305,335};
/**
* Useful millisecond constants. Although ONE_DAY and ONE_WEEK can fit
* into ints, they must be longs in order to prevent arithmetic overflow
* when performing (bug 4173516).
*/
private static final int ONE_SECOND = 1000;
private static final int ONE_MINUTE = 60*ONE_SECOND;
private static final int ONE_HOUR = 60*ONE_MINUTE;
private static final long ONE_DAY = 24*ONE_HOUR;
private static final long ONE_WEEK = 7*ONE_DAY;
/**
* The point at which the Gregorian calendar rules are used, measured in
* milliseconds from the standard epoch. Default is October 15, 1582
* (Gregorian) 00:00:00 UTC or -12219292800000L. For this value, October 4,
* 1582 (Julian) is followed by October 15, 1582 (Gregorian). This
* corresponds to Julian day number 2299161.
*/
private static final long gregorianCutover = -12219292800000L;
/**
* The year of the gregorianCutover, with 0 representing
* 1 BC, -1 representing 2 BC, etc.
*/
private static final int gregorianCutoverYear = 1582;
public CalendarImpl() {
super();
}
/**
* Converts UTC as milliseconds to time field values.
*/
protected void computeFields() {
int rawOffset = getTimeZone().getRawOffset();
long localMillis = time + rawOffset;
// Check for very extreme values -- millis near Long.MIN_VALUE or
// Long.MAX_VALUE. For these values, adding the zone offset can push
// the millis past MAX_VALUE to MIN_VALUE, or vice versa. This produces
// the undesirable effect that the time can wrap around at the ends,
// yielding, for example, a Date(Long.MAX_VALUE) with a big BC year
// (should be AD). Handle this by pinning such values to Long.MIN_VALUE
// or Long.MAX_VALUE. - liu 8/11/98 bug 4149677
if (time > 0 && localMillis < 0 && rawOffset > 0) {
localMillis = Long.MAX_VALUE;
} else if (time < 0 && localMillis > 0 && rawOffset < 0) {
localMillis = Long.MIN_VALUE;
}
// Time to fields takes the wall millis (Standard or DST).
timeToFields(localMillis);
long ndays = (localMillis / ONE_DAY);
int millisInDay = (int)(localMillis - (ndays * ONE_DAY));
if (millisInDay < 0) millisInDay += ONE_DAY;
// Call getOffset() to get the TimeZone offset.
// The millisInDay value must be standard local millis.
int dstOffset = getTimeZone().getOffset(AD,
this.fields[YEAR],
this.fields[MONTH],
this.fields[DATE],
this.fields[DAY_OF_WEEK],
millisInDay) - rawOffset;
// Adjust our millisInDay for DST, if necessary.
millisInDay += dstOffset;
// If DST has pushed us into the next day,
// we must call timeToFields() again.
// This happens in DST between 12:00 am and 1:00 am every day.
// The call to timeToFields() will give the wrong day,
// since the Standard time is in the previous day
if (millisInDay >= ONE_DAY) {
long dstMillis = localMillis + dstOffset;
millisInDay -= ONE_DAY;
// As above, check for and pin extreme values
if (localMillis > 0 && dstMillis < 0 && dstOffset > 0) {
dstMillis = Long.MAX_VALUE;
} else if (localMillis < 0 && dstMillis > 0 && dstOffset < 0) {
dstMillis = Long.MIN_VALUE;
}
timeToFields(dstMillis);
}
// Fill in all time-related fields based on millisInDay.
// so as not to perturb flags.
this.fields[MILLISECOND] = millisInDay % 1000;
millisInDay /= 1000;
this.fields[SECOND] = millisInDay % 60;
millisInDay /= 60;
this.fields[MINUTE] = millisInDay % 60;
millisInDay /= 60;
this.fields[HOUR_OF_DAY] = millisInDay;
this.fields[AM_PM] = millisInDay / 12;
this.fields[HOUR] = millisInDay % 12;
}
/**
* Convert the time as milliseconds to the date fields. Millis must be
* given as local wall millis to get the correct local day. For example,
* if it is 11:30 pm Standard, and DST is in effect, the correct DST millis
* must be passed in to get the right date.
* <p>
* Fields that are completed by this method: YEAR, MONTH, DATE, DAY_OF_WEEK.
* @param theTime the time in wall millis (either Standard or DST),
* whichever is in effect
*/
private void timeToFields(long theTime) {
int dayOfYear, rawYear;
boolean isLeap;
// Compute the year, month, and day of month from the given millis
if (theTime >= gregorianCutover) {
// The Gregorian epoch day is zero for Monday January 1, year 1.
long gregorianEpochDay =
millisToJulianDay(theTime) - JAN_1_1_JULIAN_DAY;
// Here we convert from the day number to the multiple radix
// representation. We use 400-year, 100-year, and 4-year cycles.
// For example, the 4-year cycle has 4 years + 1 leap day; giving
// 1461 == 365*4 + 1 days.
int[] rem = new int[1];
// 400-year cycle length
int n400 = floorDivide(gregorianEpochDay, 146097, rem);
// 100-year cycle length
int n100 = floorDivide(rem[0], 36524, rem);
// 4-year cycle length
int n4 = floorDivide(rem[0], 1461, rem);
int n1 = floorDivide(rem[0], 365, rem);
rawYear = 400*n400 + 100*n100 + 4*n4 + n1;
// zero-based day of year
dayOfYear = rem[0];
// Dec 31 at end of 4- or 400-yr cycle
if (n100 == 4 || n1 == 4) {
dayOfYear = 365;
} else {
++rawYear;
}
// equiv. to (rawYear%4 == 0)
isLeap =
((rawYear&0x3) == 0) && (rawYear%100 != 0 || rawYear%400 == 0);
// Gregorian day zero is a Monday
this.fields[DAY_OF_WEEK] = (int)((gregorianEpochDay+1) % 7);
} else {
// The Julian epoch day (not the same as Julian Day)
// is zero on Saturday December 30, 0 (Gregorian).
long julianEpochDay =
millisToJulianDay(theTime) - (JAN_1_1_JULIAN_DAY - 2);
rawYear = (int) floorDivide(4*julianEpochDay + 1464, 1461);
// Compute the Julian calendar day number for January 1, year
long january1 = 365*(rawYear-1) + floorDivide(rawYear-1, 4);
dayOfYear = (int)(julianEpochDay - january1); // 0-based
// Julian leap years occurred historically every 4 years starting
// with 8 AD. Before 8 AD the spacing is irregular; every 3 years
// from 45 BC to 9 BC, and then none until 8 AD. However, we don't
// implement this historical detail; instead, we implement the
// computationally cleaner proleptic calendar, which assumes
// consistent 4-year cycles throughout time.
// equiv. to (rawYear%4 == 0)
isLeap = ((rawYear&0x3) == 0);
// Julian calendar day zero is a Saturday
this.fields[DAY_OF_WEEK] = (int)((julianEpochDay-1) % 7);
}
// Common Julian/Gregorian calculation
int correction = 0;
// zero-based DOY for March 1
int march1 = isLeap ? 60 : 59;
if (dayOfYear >= march1) correction = isLeap ? 1 : 2;
// zero-based month
int month_field = (12 * (dayOfYear + correction) + 6) / 367;
// one-based DOM
int date_field = dayOfYear -
(isLeap ? LEAP_NUM_DAYS[month_field] : NUM_DAYS[month_field]) + 1;
// Normalize day of week
this.fields[DAY_OF_WEEK] += (this.fields[DAY_OF_WEEK] < 0) ? (SUNDAY+7) : SUNDAY;
this.fields[YEAR] = rawYear;
// If year is < 1 we are in BC
if (this.fields[YEAR] < 1) {
this.fields[YEAR] = 1 - this.fields[YEAR];
}
// 0-based
this.fields[MONTH] = month_field + JANUARY;
this.fields[DATE] = date_field;
}
/*
* The following two static arrays are used privately by the
* <code>toString(Calendar calendar)</code> function below.
*/
static String[] months = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
static String[] days = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
/**
* Converts this <code>Date</code> object to a <code>String</code>
* of the form:
* <blockquote><pre>
* dow mon dd hh:mm:ss zzz yyyy</pre></blockquote>
* where:<ul>
* <li><tt>dow</tt> is the day of the week (<tt>Sun, Mon, Tue, Wed,
* Thu, Fri, Sat</tt>).
* <li><tt>mon</tt> is the month (<tt>Jan, Feb, Mar, Apr, May, Jun,
* Jul, Aug, Sep, Oct, Nov, Dec</tt>).
* <li><tt>dd</tt> is the day of the month (<tt>01</tt> through
* <tt>31</tt>), as two decimal digits.
* <li><tt>hh</tt> is the hour of the day (<tt>00</tt> through
* <tt>23</tt>), as two decimal digits.
* <li><tt>mm</tt> is the minute within the hour (<tt>00</tt> through
* <tt>59</tt>), as two decimal digits.
* <li><tt>ss</tt> is the second within the minute (<tt>00</tt> through
* <tt>61</tt>, as two decimal digits.
* <li><tt>zzz</tt> is the time zone (and may reflect daylight savings
* time). If time zone information is not available,
* then <tt>zzz</tt> is empty - that is, it consists
* of no characters at all.
* <li><tt>yyyy</tt> is the year, as four decimal digits.
* </ul>
*
* @return a string representation of this date.
*/
public static String toString(Calendar calendar) {
// Printing in the absence of a Calendar
// implementation class is not supported
if (calendar == null) {
return "Thu Jan 01 00:00:00 UTC 1970";
}
int dow = calendar.get(Calendar.DAY_OF_WEEK);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour_of_day = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int seconds = calendar.get(Calendar.SECOND);
int year = calendar.get(Calendar.YEAR);
String yr = Integer.toString(year);
TimeZone zone = calendar.getTimeZone();
String zoneID = zone.getID();
if (zoneID == null) zoneID = "";
// The total size of the string buffer
// 3+1+3+1+2+1+2+1+2+1+2+1+zoneID.length+1+yr.length
// = 21 + zoneID.length + yr.length
StringBuffer sb = new StringBuffer(25 + zoneID.length() + yr.length());
sb.append(days[dow-1]).append(' ');
sb.append(months[month]).append(' ');
appendTwoDigits(sb, day).append(' ');
appendTwoDigits(sb, hour_of_day).append(':');
appendTwoDigits(sb, minute).append(':');
appendTwoDigits(sb, seconds).append(' ');
if (zoneID.length() > 0) sb.append(zoneID).append(' ');
appendFourDigits(sb, year);
return sb.toString();
}
/**
* Converts this <code>Date</code> object to a <code>String</code>.
* The output format is as follows:
* <blockquote><pre>yyyy MM dd hh mm ss +zzzz</pre></blockquote>
* where:<ul>
* <li><dd>yyyy</dd> is the year, as four decimal digits.
* Year values larger than <dd>9999</dd> will be truncated
* to <dd>9999</dd>.
* <li><dd>MM</dd> is the month (<dd>01</dd> through <dd>12</dd>),
* as two decimal digits.
* <li><dd>dd</dd> is the day of the month (<dd>01</dd> through
* <dd>31</dd>), as two decimal digits.
* <li><dd>hh</dd> is the hour of the day (<dd>00</dd> through
* <dd>23</dd>), as two decimal digits.
* <li><dd>mm</dd> is the minute within the hour (<dd>00</dd>
* through <dd>59</dd>), as two decimal digits.
* <li><dd>ss</dd> is the second within the minute (<dd>00</dd>
* through <dd>59</dd>), as two decimal digits.
* <li><dd>zzzz</dd> is the time zone offset in hours and minutes
* (four decimal digits <dd>"hhmm"</dd>) relative to GMT,
* preceded by a "+" or "-" character (<dd>-1200</dd>
* through <dd>+1200</dd>).
* For instance, Pacific Standard Time zone is printed
* as <dd>-0800</dd>. GMT is printed as <dd>+0000</dd>.
* </ul>
*
* @return a string representation of this date.
*/
public static String toISO8601String(Calendar calendar) {
// Printing in the absence of a Calendar
// implementation class is not supported
if (calendar == null) {
return "0000 00 00 00 00 00 +0000";
}
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1;
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour_of_day = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int seconds = calendar.get(Calendar.SECOND);
String yr = Integer.toString(year);
// The total size of the string buffer
// yr.length+1+2+1+2+1+2+1+2+1+2+1+5 = 25 + yr.length
StringBuffer sb = new StringBuffer(25 + yr.length());
appendFourDigits(sb, year).append(' ');
appendTwoDigits(sb, month).append(' ');
appendTwoDigits(sb, day).append(' ');
appendTwoDigits(sb, hour_of_day).append(' ');
appendTwoDigits(sb, minute).append(' ');
appendTwoDigits(sb, seconds).append(' ');
// TimeZone offset is represented in milliseconds.
// Convert the offset to minutes:
TimeZone t = calendar.getTimeZone();
int zoneOffsetInMinutes = t.getRawOffset() / 1000 / 60;
if (zoneOffsetInMinutes < 0) {
zoneOffsetInMinutes = Math.abs(zoneOffsetInMinutes);
sb.append('-');
} else {
sb.append('+');
}
int zoneHours = zoneOffsetInMinutes / 60;
int zoneMinutes = zoneOffsetInMinutes % 60;
appendTwoDigits(sb, zoneHours);
appendTwoDigits(sb, zoneMinutes);
return sb.toString();
}
private static StringBuffer appendFourDigits(StringBuffer sb, int number) {
if (number >= 0 && number < 1000) {
sb.append('0');
if (number < 100) {
sb.append('0');
}
if (number < 10) {
sb.append('0');
}
}
return sb.append(number);
}
private static StringBuffer appendTwoDigits(StringBuffer sb, int number) {
if (number < 10) {
sb.append('0');
}
return sb.append(number);
}
/////////////////////////////
// Fields => Time computation
/////////////////////////////
/**
* Converts time field values to UTC as milliseconds.
* @exception IllegalArgumentException if any fields are invalid.
*/
protected void computeTime() {
correctTime();
// This function takes advantage of the fact that unset fields in
// the time field list have a value of zero.
// First, use the year to determine whether to use the Gregorian or the
// Julian calendar. If the year is not the year of the cutover, this
// computation will be correct. But if the year is the cutover year,
// this may be incorrect. In that case, assume the Gregorian calendar,
// make the computation, and then recompute if the resultant millis
// indicate the wrong calendar has been assumed.
// A date such as Oct. 10, 1582 does not exist in a Gregorian calendar
// with the default changeover of Oct. 15, 1582, since in such a
// calendar Oct. 4 (Julian) is followed by Oct. 15 (Gregorian). This
// algorithm will interpret such a date using the Julian calendar,
// yielding Oct. 20, 1582 (Gregorian).
int year = this.fields[YEAR];
boolean isGregorian = year >= gregorianCutoverYear;
long julianDay = calculateJulianDay(isGregorian, year);
long millis = julianDayToMillis(julianDay);
// The following check handles portions of the cutover year BEFORE the
// cutover itself happens. The check for the julianDate number is for a
// rare case; it's a hardcoded number, but it's efficient. The given
// Julian day number corresponds to Dec 3, 292269055 BC, which
// corresponds to millis near Long.MIN_VALUE. The need for the check
// arises because for extremely negative Julian day numbers, the millis
// actually overflow to be positive values. Without the check, the
// initial date is interpreted with the Gregorian calendar, even when
// the cutover doesn't warrant it.
if (isGregorian != (millis >= gregorianCutover) &&
julianDay != -106749550580L) { // See above
julianDay = calculateJulianDay(!isGregorian, year);
millis = julianDayToMillis(julianDay);
}
// Do the time portion of the conversion.
int millisInDay = 0;
// Hours
// Don't normalize here; let overflow bump into the next period.
// This is consistent with how we handle other fields.
millisInDay += this.fields[HOUR_OF_DAY];
millisInDay *= 60;
// now get minutes
millisInDay += this.fields[MINUTE];
millisInDay *= 60;
// now get seconds
millisInDay += this.fields[SECOND];
millisInDay *= 1000;
// now get millis
millisInDay += this.fields[MILLISECOND];
// Compute the time zone offset and DST offset. There are two potential
// ambiguities here. We'll assume a 2:00 am (wall time) switchover time
// for discussion purposes here.
// 1. The transition into DST. Here, a designated time of 2:00 am - 2:59 am
// can be in standard or in DST depending. However, 2:00 am is an invalid
// representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST).
// We assume standard time.
// 2. The transition out of DST. Here, a designated time of 1:00 am - 1:59 am
// can be in standard or DST. Both are valid representations (the rep
// jumps from 1:59:59 DST to 1:00:00 Std).
// Again, we assume standard time.
// We use the TimeZone object to get the zone offset
int zoneOffset = getTimeZone().getRawOffset();
// Now add date and millisInDay together, to make millis contain local wall
// millis, with no zone or DST adjustments
millis += millisInDay;
// Normalize the millisInDay to 0..ONE_DAY-1. If the millis is out
// of range, then we must call timeToFields() to recompute our
// fields.
int[] normalizedMillisInDay = new int[1];
floorDivide(millis, (int)ONE_DAY, normalizedMillisInDay);
// We need to have the month, the day, and the day of the week.
// Calling timeToFields will compute the MONTH and DATE fields.
//
// It's tempting to try to use DAY_OF_WEEK here, if it
// is set, but we CAN'T. Even if it's set, it might have
// been set wrong by the user. We should rely only on
// the Julian day number, which has been computed correctly
// using the disambiguation algorithm above. [LIU]
int dow = julianDayToDayOfWeek(julianDay);
// It's tempting to try to use DAY_OF_WEEK here, if it
// is set, but we CAN'T. Even if it's set, it might have
// been set wrong by the user. We should rely only on
// the Julian day number, which has been computed correctly
// using the disambiguation algorithm above. [LIU]
int dstOffset = getTimeZone().getOffset(AD,
this.fields[YEAR],
this.fields[MONTH],
this.fields[DATE],
dow,
normalizedMillisInDay[0]) -
zoneOffset;
// Note: Because we pass in wall millisInDay, rather than
// standard millisInDay, we interpret "1:00 am" on the day
// of cessation of DST as "1:00 am Std" (assuming the time
// of cessation is 2:00 am).
// Store our final computed GMT time, with timezone adjustments.
time = millis - zoneOffset - dstOffset;
}
/**
* Compute the Julian day number under either the Gregorian or the
* Julian calendar, using the given year and the remaining fields.
* @param isGregorian if true, use the Gregorian calendar
* @param year the adjusted year number, with 0 indicating the
* year 1 BC, -1 indicating 2 BC, etc.
* @return the Julian day number
*/
private long calculateJulianDay(boolean isGregorian, int year) {
int month = 0;
month = this.fields[MONTH] - JANUARY;
// If the month is out of range, adjust it into range
if (month < 0 || month > 11) {
int[] rem = new int[1];
year += floorDivide(month, 12, rem);
month = rem[0];
}
boolean isLeap = year%4 == 0;
long julianDay =
365L*(year - 1) + floorDivide((year - 1), 4) + (JAN_1_1_JULIAN_DAY - 3);
if (isGregorian) {
isLeap = isLeap && ((year%100 != 0) || (year%400 == 0));
// Add 2 because Gregorian calendar starts 2 days after Julian calendar
julianDay +=
floorDivide((year - 1), 400) - floorDivide((year - 1), 100) + 2;
}
// At this point julianDay is the 0-based day BEFORE the first day of
// January 1, year 1 of the given calendar. If julianDay == 0, it
// specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
// or Gregorian).
julianDay += isLeap ? LEAP_NUM_DAYS[month] : NUM_DAYS[month];
julianDay += this.fields[DATE];
return julianDay;
}
/**
* Validates the field values for HOUR_OF_DAY, AM_PM and HOUR
* The calendar will give preference in the following order
* HOUR_OF_DAY, AM_PM, HOUR
*/
private void correctTime() {
int value;
if (isSet[HOUR_OF_DAY]) {
value = this.fields[HOUR_OF_DAY] % 24;
this.fields[HOUR_OF_DAY] = value;
this.fields[AM_PM] = (value < 12) ? AM : PM;
this.isSet[HOUR_OF_DAY] = false;
return;
}
if(isSet[AM_PM]) {
// Determines AM PM with the 24 hour clock
// This prevents the user from inputing an invalid one.
if (this.fields[AM_PM] != AM && this.fields[AM_PM] != PM) {
value = this.fields[HOUR_OF_DAY];
this.fields[AM_PM] = (value < 12) ? AM : PM;
}
this.isSet[AM_PM] = false;
}
if (isSet[HOUR]) {
value = this.fields[HOUR];
if (value > 12) {
this.fields[HOUR_OF_DAY] = (value % 12) + 12;
this.fields[HOUR] = value % 12;
this.fields[AM_PM] = PM;
} else {
if (this.fields[AM_PM] == PM) {
this.fields[HOUR_OF_DAY] = value + 12;
} else {
this.fields[HOUR_OF_DAY] = value;
}
}
this.isSet[HOUR] = false;
}
}
/////////////////
// Implementation
/////////////////
/**
* Converts time as milliseconds to Julian day.
* @param millis the given milliseconds.
* @return the Julian day number.
*/
private static long millisToJulianDay(long millis) {
return EPOCH_JULIAN_DAY + floorDivide(millis, ONE_DAY);
}
/**
* Converts Julian day to time as milliseconds.
* @param julian the given Julian day number.
* @return time as milliseconds.
*/
private static long julianDayToMillis(long julian) {
return (julian - EPOCH_JULIAN_DAY) * ONE_DAY;
}
private static int julianDayToDayOfWeek(long julian) {
// If julian is negative, then julian%7 will be negative, so we adjust
// accordingly. We add 1 because Julian day 0 is Monday.
int dayOfWeek = (int)((julian + 1) % 7);
return dayOfWeek + ((dayOfWeek < 0) ? (7 + SUNDAY) : SUNDAY);
}
/**
* Divide two long integers, returning the floor of the quotient.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
* E.g., <code>-1/4</code> => 0
* but <code>floorDivide(-1,4)</code> => -1.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @return the floor of the quotient.
*/
public static long floorDivide(long numerator, long denominator) {
// We do this computation in order to handle
// a numerator of Long.MIN_VALUE correctly
return (numerator >= 0) ?
numerator / denominator :
((numerator + 1) / denominator) - 1;
}
/**
* Divide two integers, returning the floor of the quotient.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
* E.g., <code>-1/4</code> => 0
* but <code>floorDivide(-1,4)</code> => -1.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @return the floor of the quotient.
*/
private static int floorDivide(int numerator, int denominator) {
// We do this computation in order to handle
// a numerator of Integer.MIN_VALUE correctly
return (numerator >= 0) ?
numerator / denominator :
((numerator + 1) / denominator) - 1;
}
/**
* Divide two integers, returning the floor of the quotient, and
* the modulus remainder.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
* E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
* but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* <code>numerator mod denominator</code> is returned. Unlike <code>numerator
* % denominator</code>, this will always be non-negative.
* @return the floor of the quotient.
*/
private static int
floorDivide(int numerator, int denominator, int[] remainder) {
if (numerator >= 0) {
remainder[0] = numerator % denominator;
return numerator / denominator;
}
int quotient = ((numerator + 1) / denominator) - 1;
remainder[0] = numerator - (quotient * denominator);
return quotient;
}
/**
* Divide two integers, returning the floor of the quotient, and
* the modulus remainder.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
* E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
* but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* <code>numerator mod denominator</code> is returned. Unlike <code>numerator
* % denominator</code>, this will always be non-negative.
* @return the floor of the quotient.
*/
private static int
floorDivide(long numerator, int denominator, int[] remainder) {
if (numerator >= 0) {
remainder[0] = (int)(numerator % denominator);
return (int)(numerator / denominator);
}
int quotient = (int)(((numerator + 1) / denominator) - 1);
remainder[0] = (int)(numerator - (quotient * denominator));
return quotient;
}
}
| gpl-2.0 |
tux-00/ansible | lib/ansible/module_utils/netconf.py | 3772 | # This code is part of Ansible, but is an independent component.
# This particular file snippet, and this file snippet only, is BSD licensed.
# Modules you write using this snippet, which is embedded dynamically by Ansible
# still belong to the author of the module, and may assign their own license
# to the complete work.
#
# (c) 2017 Red Hat Inc.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
from contextlib import contextmanager
from xml.etree.ElementTree import Element, SubElement, fromstring, tostring
from ansible.module_utils.connection import exec_command
NS_MAP = {'nc': "urn:ietf:params:xml:ns:netconf:base:1.0"}
def send_request(module, obj, check_rc=True):
request = tostring(obj)
rc, out, err = exec_command(module, request)
if rc != 0 and check_rc:
error_root = fromstring(err)
fake_parent = Element('root')
fake_parent.append(error_root)
error_list = fake_parent.findall('.//nc:rpc-error', NS_MAP)
if not error_list:
module.fail_json(msg=str(err))
warnings = []
for rpc_error in error_list:
message = rpc_error.find('./nc:error-message', NS_MAP).text
severity = rpc_error.find('./nc:error-severity', NS_MAP).text
if severity == 'warning':
warnings.append(message)
else:
module.fail_json(msg=str(err))
return warnings
return fromstring(out)
def children(root, iterable):
for item in iterable:
try:
ele = SubElement(ele, item)
except NameError:
ele = SubElement(root, item)
def lock(module, target='candidate'):
obj = Element('lock')
children(obj, ('target', target))
return send_request(module, obj)
def unlock(module, target='candidate'):
obj = Element('unlock')
children(obj, ('target', target))
return send_request(module, obj)
def commit(module):
return send_request(module, Element('commit'))
def discard_changes(module):
return send_request(module, Element('discard-changes'))
def validate(module):
obj = Element('validate')
children(obj, ('source', 'candidate'))
return send_request(module, obj)
def get_config(module, source='running', filter=None):
obj = Element('get-config')
children(obj, ('source', source))
children(obj, ('filter', filter))
return send_request(module, obj)
@contextmanager
def locked_config(module):
try:
lock(module)
yield
finally:
unlock(module)
| gpl-3.0 |
mzemel/kpsu.org | vendor/gems/ruby/1.8/gems/activerecord-3.0.3/lib/active_record/named_scope.rb | 5522 | require 'active_support/core_ext/array'
require 'active_support/core_ext/hash/except'
require 'active_support/core_ext/kernel/singleton_class'
require 'active_support/core_ext/object/blank'
module ActiveRecord
# = Active Record Named \Scopes
module NamedScope
extend ActiveSupport::Concern
module ClassMethods
# Returns an anonymous \scope.
#
# posts = Post.scoped
# posts.size # Fires "select count(*) from posts" and returns the count
# posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
#
# fruits = Fruit.scoped
# fruits = fruits.where(:colour => 'red') if options[:red_only]
# fruits = fruits.limit(10) if limited?
#
# Anonymous \scopes tend to be useful when procedurally generating complex
# queries, where passing intermediate values (\scopes) around as first-class
# objects is convenient.
#
# You can define a \scope that applies to all finders using
# ActiveRecord::Base.default_scope.
def scoped(options = nil)
if options
scoped.apply_finder_options(options)
else
current_scoped_methods ? relation.merge(current_scoped_methods) : relation.clone
end
end
def scopes
read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
end
# Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
# such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
#
# class Shirt < ActiveRecord::Base
# scope :red, where(:color => 'red')
# scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true)
# end
#
# The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
# in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
#
# Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
# resembles the association object constructed by a <tt>has_many</tt> declaration. For instance,
# you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>.
# Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable;
# <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
# all behave as if Shirt.red really was an Array.
#
# These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
# all shirts that are both red and dry clean only.
# Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
# returns the number of garments for which these criteria obtain. Similarly with
# <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
#
# All \scopes are available as class methods on the ActiveRecord::Base descendant upon which
# the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
#
# class Person < ActiveRecord::Base
# has_many :shirts
# end
#
# then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
# only shirts.
#
# Named \scopes can also be procedural:
#
# class Shirt < ActiveRecord::Base
# scope :colored, lambda {|color| where(:color => color) }
# end
#
# In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
#
# Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
#
# class Shirt < ActiveRecord::Base
# scope :red, where(:color => 'red') do
# def dom_id
# 'red_shirts'
# end
# end
# end
#
# Scopes can also be used while creating/building a record.
#
# class Article < ActiveRecord::Base
# scope :published, where(:published => true)
# end
#
# Article.published.new.published # => true
# Article.published.create.published # => true
def scope(name, scope_options = {}, &block)
name = name.to_sym
valid_scope_name?(name)
extension = Module.new(&block) if block_given?
scopes[name] = lambda do |*args|
options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
relation = if options.is_a?(Hash)
scoped.apply_finder_options(options)
elsif options
scoped.merge(options)
else
scoped
end
extension ? relation.extending(extension) : relation
end
singleton_class.send(:redefine_method, name, &scopes[name])
end
def named_scope(*args, &block)
ActiveSupport::Deprecation.warn("Base.named_scope has been deprecated, please use Base.scope instead", caller)
scope(*args, &block)
end
protected
def valid_scope_name?(name)
if !scopes[name] && respond_to?(name, true)
logger.warn "Creating scope :#{name}. " \
"Overwriting existing method #{self.name}.#{name}."
end
end
end
end
end
| gpl-3.0 |
Akheon23/gmp4 | mpn/generic/redc_1.c | 1399 | /* mpn_redc_1. Set cp[] <- up[]/R^n mod mp[]. Clobber up[].
mp[] is n limbs; up[] is 2n limbs.
THIS IS AN INTERNAL FUNCTION WITH A MUTABLE INTERFACE. IT IS ONLY
SAFE TO REACH THIS FUNCTION THROUGH DOCUMENTED INTERFACES.
Copyright (C) 2000, 2001, 2002, 2004, 2008 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library. If not, see http://www.gnu.org/licenses/. */
#include "gmp.h"
#include "gmp-impl.h"
void
mpn_redc_1 (mp_ptr rp, mp_ptr up, mp_srcptr mp, mp_size_t n, mp_limb_t invm)
{
mp_size_t j;
mp_limb_t cy;
ASSERT_MPN (up, 2*n);
for (j = n - 1; j >= 0; j--)
{
up[0] = mpn_addmul_1 (up, mp, n, (up[0] * invm) & GMP_NUMB_MASK);
up++;
}
cy = mpn_add_n (rp, up, up - n, n);
if (cy != 0)
mpn_sub_n (rp, rp, mp, n);
}
| gpl-3.0 |
dkodnik/PanicButton | docs/SECURITY.md | 6190 | # Panic Button - Security Documentation
## Introduction
This Security Documentation for Panic Button aims to communicate some of the ways that Panic Button attempts to protect its user or user's data against different types of adverse situations. It also helps understand what the application is NOT designed to achieve in terms of security.
### What do I need to know as a user?
It is important that you understand and assess the trade-offs you make in your security when using Panic Button.
Always remember:
> Panic Button only improves your safety when your contacts are in a position to act. The disguise aims to delay the discovery of the application for as long as possible while it sends location updates to your chosen contacts. However, this does not prevent a competent attacker from accessing the content or recipient of your messages, including your location.
The mobile networks that allow you to send an SMS are not built to protect your privacy or the content of your messages. This is true for all calls and SMS communications you make, including SMS alerts sent by Panic Button.
This present you and your contacts with direct risks if the groups who are threatening you have partnerships with the telecommunications companies in your country or have access to equipment that allows them to intercept telecommunications.
If you are using Panic Button in your work, we encourage you to visit our help pages to understand more about the general security risks of using a mobile phone. There is a list of suggested resources where you can learn about additional tools and strategies to mitigate against some of the risks of using a mobile phone.
The rest of this document is primarily for use by the technology team as a basis to develop a formal threat model that will be used to evaluate the implications of technology implementation choices throughout the application development life-cycle.
### How can I get involved in improving the security of Panic Button?
We're looking into all options to make Panic Button safer and we want to hear about your ideas and recommendations. We have listed a few Open Questions in this document and we're hoping to discuss their feasibility and desirability openly.
## Threat related Issues
### Main goals
* Send alert messages and location to trusted contacts in case of emergency.
* Disguise the application to send alert messages and location for as long as possible.
### Security goals
* Prevent discovery of the application and disguise for non-competent users exploring the phone (such as during a routine check by a non technically savvy law enforcement officer)
* Prevent access to application data (in particular contacts) to non-competent users.
* Prevent data network operators (wifi and mobile data) from being able to identify users of the application. Telecommunication operators may be able to identify users.
* Prevent the distribution of corrupted or malicious updates of the application.
### Security non goals
* No protection against the identification of the application and access to the application data by technically competent adversaries with access to the phone or to the GSM infrastructure.
* No protection against access to the existence of and the content of messages sent from the App by technically competent adversaries, and adversaries with access to the GSM infrastructure.
* No protection against the tracking of the location of the user of the application by technically competent adversaries.
## Open Questions
- How much is the Content API needed? How needed is it to protect the Content API? It is using HTTPS currently, it could use pinned SSL certificate to prevent MITM. Content from the content API goes into the database but the code protects against SQL injection.
- With regards to encrypted data store. While adversaries that have access to the infrastructure would know the identity of the contacts that are being alerted, in the event that a user is stopped before an alert is sent, if the data store is encrypted then we won't be revealing that information.
> (Development note: The current recommended approach should probably be to use MODE_PRIVATE as described here (http://android-developers.blogspot.de/2013/02/using-cryptography-to-store-credentials.html) which would be equivalent to encrypting the preference file and storing the encryption key in internal storage. If so then Android device encryption should also be recommended. Possibly the "even more security" approach in this doc could be used but might not be safe for Android < 4.2. Using it with a 4 digit pins seem to also open it to brute force attacks.
- Delete SMS sent items : SMS alerts should be deleted from the phone or not stored at all in the first place.
- Should the application help with face-to-face setup of codewords? For example, if Alice, Bob and Carol were face-to-face, we could simultaneously use the application to establish a codeword for each contact. When Alice enters Bob into her phone she would enter the codeword. I could use a different word for Carol. It would never be transmitted over the network, EXCEPT in an alert. If Bob or Carol received an alert from me without the codeword they would know it was not authentic. This might prevent an adversary from sending messages like “I am in danger” with fake location data.
- Should the application be able to identify inbound alerts? For example, if the application on my phone sees an alert from the application on Tanya’s phone it might use a more aggressive sound/vibrate/on screen alert. I’d hate to miss an alert from a friend because I ignored the cute everyday SMS notifier sound. When/if the application makes it onto iOS, this might help override the “quiet time” functionality in newer versions of iOS.
- Should the application facilitate “Alert if unresponsive” notifications? If I am heading into a contentious situation, it might be useful to notify my contacts if I do not somehow indicate that I am ok. Perhaps this is a countdown timer. I set the timer to 60 minutes and if I do not clear or reset the timer within 60 minutes my contacts are notified.
| gpl-3.0 |
sehrhardt/espresso | src/core/immersed_boundary/ibm_cuda_interface.cpp | 7514 |
// *******
// This is an internal file of the IMMERSED BOUNDARY implementation
// It should not be included by any main Espresso routines
// Functions to be exported for Espresso are in ibm_main.hpp
#include "config.hpp"
#ifdef IMMERSED_BOUNDARY
#include <mpi.h>
#include "cells.hpp"
#include "grid.hpp"
#include "communication.hpp"
#include "particle_data.hpp"
#include "integrate.hpp"
#include "immersed_boundary/ibm_cuda_interface.hpp"
/// MPI tags for sending velocities and receiving particles
#define REQ_CUDAIBMSENDVEL 0xcc03
#define REQ_CUDAIBMGETPART 0xcc04
// Variables for communication
IBM_CUDA_ParticleDataInput *IBM_ParticleDataInput_host = NULL;
IBM_CUDA_ParticleDataOutput *IBM_ParticleDataOutput_host = NULL;
/*****************
IBM_cuda_mpi_get_particles
Gather particle positions on the master node in order to communicate them to GPU
We transfer all particles (real and virtual), but acutally we would only need the virtual ones
Room for improvement...
*****************/
void IBM_cuda_mpi_get_particles_slave();
// Analogous to the usual cuda_mpi_get_particles function
void IBM_cuda_mpi_get_particles()
{
int g, pnode;
Cell *cell;
int c;
MPI_Status status;
int *sizes = (int*) Utils::malloc(sizeof(int)*n_nodes);
int n_part = cells_get_n_particles();
/* first collect number of particles on each node */
MPI_Gather(&n_part, 1, MPI_INT, sizes, 1, MPI_INT, 0, comm_cart);
if(this_node > 0){
/* call slave functions to provide the slave datas */
IBM_cuda_mpi_get_particles_slave();
}
else {
/* master: fetch particle informations into 'result' */
g = 0;
for (pnode = 0; pnode < n_nodes; pnode++) {
if (sizes[pnode] > 0) {
if (pnode == 0) {
for (c = 0; c < local_cells.n; c++) {
Particle *part;
int npart;
int dummy[3] = {0,0,0};
double pos[3];
cell = local_cells.cell[c];
part = cell->part;
npart = cell->n;
for (int i=0;i<npart;i++) {
memmove(pos, part[i].r.p, 3*sizeof(double));
fold_position(pos, dummy);
IBM_ParticleDataInput_host[i+g].pos[0] = (float)pos[0];
IBM_ParticleDataInput_host[i+g].pos[1] = (float)pos[1];
IBM_ParticleDataInput_host[i+g].pos[2] = (float)pos[2];
IBM_ParticleDataInput_host[i+g].f[0] = (float)part[i].f.f[0];
IBM_ParticleDataInput_host[i+g].f[1] = (float)part[i].f.f[1];
IBM_ParticleDataInput_host[i+g].f[2] = (float)part[i].f.f[2];
IBM_ParticleDataInput_host[i+g].isVirtual = part[i].p.isVirtual;
}
g += npart;
}
}
else {
MPI_Recv(&IBM_ParticleDataInput_host[g], sizes[pnode]*sizeof(IBM_CUDA_ParticleDataInput), MPI_BYTE, pnode, REQ_CUDAIBMGETPART,
comm_cart, &status);
g += sizes[pnode];
}
}
}
}
COMM_TRACE(fprintf(stderr, "%d: finished get\n", this_node));
free(sizes);
}
void IBM_cuda_mpi_get_particles_slave()
{
int n_part;
int g;
IBM_CUDA_ParticleDataInput *particle_input_sl;
Cell *cell;
int c, i;
n_part = cells_get_n_particles();
COMM_TRACE(fprintf(stderr, "%d: get_particles_slave, %d particles\n", this_node, n_part));
if (n_part > 0) {
/* get (unsorted) particle informations as an array of type 'particle' */
/* then get the particle information */
// particle_data_host_sl = (IBM_CUDA_ParticleDataInput*) Utils::malloc(n_part*sizeof(IBM_CUDA_ParticleData));
particle_input_sl = new IBM_CUDA_ParticleDataInput[n_part];
g = 0;
for (c = 0; c < local_cells.n; c++) {
Particle *part;
int npart;
int dummy[3] = {0,0,0};
double pos[3];
cell = local_cells.cell[c];
part = cell->part;
npart = cell->n;
for (i=0;i<npart;i++) {
memmove(pos, part[i].r.p, 3*sizeof(double));
fold_position(pos, dummy);
particle_input_sl[i+g].pos[0] = (float)pos[0];
particle_input_sl[i+g].pos[1] = (float)pos[1];
particle_input_sl[i+g].pos[2] = (float)pos[2];
particle_input_sl[i+g].f[0] = (float)part[i].f.f[0];
particle_input_sl[i+g].f[1] = (float)part[i].f.f[1];
particle_input_sl[i+g].f[2] = (float)part[i].f.f[2];
particle_input_sl[i+g].isVirtual = part[i].p.isVirtual;
}
g+=npart;
}
/* and send it back to the master node */
MPI_Send(particle_input_sl, n_part*sizeof(IBM_CUDA_ParticleDataInput), MPI_BYTE, 0, REQ_CUDAIBMGETPART, comm_cart);
delete []particle_input_sl;
}
}
/*****************
IBM_cuda_mpi_send_velocities
Particle velocities have been communicated from GPU, now transmit to all nodes
******************/
// Analogous to cuda_mpi_send_forces
void IBM_cuda_mpi_send_velocities_slave();
void IBM_cuda_mpi_send_velocities()
{
int n_part;
int g, pnode;
Cell *cell;
int c;
int *sizes;
sizes = (int *) Utils::malloc(sizeof(int)*n_nodes);
n_part = cells_get_n_particles();
/* first collect number of particles on each node */
MPI_Gather(&n_part, 1, MPI_INT, sizes, 1, MPI_INT, 0, comm_cart);
/* call slave functions to provide the slave datas */
if(this_node > 0) {
IBM_cuda_mpi_send_velocities_slave();
}
else{
/* fetch particle informations into 'result' */
g = 0;
for (pnode = 0; pnode < n_nodes; pnode++) {
if (sizes[pnode] > 0) {
if (pnode == 0) {
for (c = 0; c < local_cells.n; c++) {
int npart;
cell = local_cells.cell[c];
npart = cell->n;
for (int i=0;i<npart;i++)
{
if ( cell->part[i].p.isVirtual )
{
cell->part[i].m.v[0] = (double)IBM_ParticleDataOutput_host[(i+g)].v[0];
cell->part[i].m.v[1] = (double)IBM_ParticleDataOutput_host[(i+g)].v[1];
cell->part[i].m.v[2] = (double)IBM_ParticleDataOutput_host[(i+g)].v[2];
}
}
g += npart;
}
}
else {
/* and send it back to the slave node */
MPI_Send(&IBM_ParticleDataOutput_host[g], sizes[pnode]*sizeof(IBM_CUDA_ParticleDataOutput), MPI_BYTE, pnode, REQ_CUDAIBMSENDVEL, comm_cart);
g += sizes[pnode];
}
}
}
}
COMM_TRACE(fprintf(stderr, "%d: finished send\n", this_node));
free(sizes);
}
void IBM_cuda_mpi_send_velocities_slave()
{
Cell *cell;
int c, i;
MPI_Status status;
const int n_part = cells_get_n_particles();
COMM_TRACE(fprintf(stderr, "%d: send_particles_slave, %d particles\n", this_node, n_part));
if (n_part > 0) {
int g = 0;
IBM_CUDA_ParticleDataOutput *output_sl = new IBM_CUDA_ParticleDataOutput[n_part];
MPI_Recv(output_sl, n_part*sizeof(IBM_CUDA_ParticleDataOutput), MPI_BYTE, 0, REQ_CUDAIBMSENDVEL,
comm_cart, &status);
for (c = 0; c < local_cells.n; c++) {
int npart;
cell = local_cells.cell[c];
npart = cell->n;
for (i=0;i<npart;i++)
{
if ( cell->part[i].p.isVirtual )
{
cell->part[i].m.v[0] = (double)output_sl[(i+g)].v[0];
cell->part[i].m.v[1] = (double)output_sl[(i+g)].v[1];
cell->part[i].m.v[2] = (double)output_sl[(i+g)].v[2];
}
}
g += npart;
}
delete []output_sl;
}
}
#endif | gpl-3.0 |
mixerp/mixerp | docs/api/class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.js | 1615 | var class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure =
[
[ "GetFlagForegroundColorProcedure", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#a406f266327939d646d9baeab2c4a403c", null ],
[ "GetFlagForegroundColorProcedure", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#abcd56ea5e3f8fb6f13a707c5831364ea", null ],
[ "Execute", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#a41b396d64cf0ca99e98589f3ed915e9b", null ],
[ "ObjectName", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#a495d5b167f46543baea7d9cf712e180c", null ],
[ "ObjectNamespace", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#abc8aeaedbf5be1aa716bedc14e8368b8", null ],
[ "_LoginId", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#a89488d582ef1c66a823d613c7725a88a", null ],
[ "_UserId", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#aaf895d27f639c2af0dca31c3c2942180", null ],
[ "Catalog", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#a10643564bca344c9ecc3c599a41ecb82", null ],
[ "FlagTypeId", "class_mix_e_r_p_1_1_net_1_1_schemas_1_1_core_1_1_data_1_1_get_flag_foreground_color_procedure.html#ae78c6bd596b5c7cada303842dcc96c2b", null ]
]; | gpl-3.0 |
urisimchoni/samba | source4/torture/raw/pingpong.c | 5911 | /*
Unix SMB/CIFS implementation.
ping pong test
Copyright (C) Ronnie Sahlberg 2007
Significantly based on and borrowed from lockbench.c by
Copyright (C) Andrew Tridgell 2006
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
filename is specified by
--option=torture:filename=...
number of locks is specified by
--option=torture:num_locks=...
locktimeout is specified in ms by
--option=torture:locktimeout=...
default is 100 seconds
if set to 0 pingpong will instead loop trying the lock operation
over and over until it completes.
reading from the file can be enabled with
--option=torture:read=true
writing to the file can be enabled with
--option=torture:write=true
*/
#include "includes.h"
#include "system/time.h"
#include "system/filesys.h"
#include "libcli/libcli.h"
#include "torture/util.h"
#include "torture/raw/proto.h"
static void lock_byte(struct smbcli_state *cli, int fd, int offset, int lock_timeout)
{
union smb_lock io;
struct smb_lock_entry lock;
NTSTATUS status;
try_again:
ZERO_STRUCT(lock);
io.lockx.in.ulock_cnt = 0;
io.lockx.in.lock_cnt = 1;
lock.count = 1;
lock.offset = offset;
lock.pid = cli->tree->session->pid;
io.lockx.level = RAW_LOCK_LOCKX;
io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
io.lockx.in.timeout = lock_timeout;
io.lockx.in.locks = &lock;
io.lockx.in.file.fnum = fd;
status = smb_raw_lock(cli->tree, &io);
/* If we don't use timeouts and we got file lock conflict
just try the lock again.
*/
if (lock_timeout==0) {
if ( (NT_STATUS_EQUAL(NT_STATUS_FILE_LOCK_CONFLICT, status))
||(NT_STATUS_EQUAL(NT_STATUS_LOCK_NOT_GRANTED, status)) ) {
goto try_again;
}
}
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Lock failed\n"));
exit(1);
}
}
static void unlock_byte(struct smbcli_state *cli, int fd, int offset)
{
union smb_lock io;
struct smb_lock_entry lock;
NTSTATUS status;
ZERO_STRUCT(lock);
io.lockx.in.ulock_cnt = 1;
io.lockx.in.lock_cnt = 0;
lock.count = 1;
lock.offset = offset;
lock.pid = cli->tree->session->pid;
io.lockx.level = RAW_LOCK_LOCKX;
io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
io.lockx.in.timeout = 100000;
io.lockx.in.locks = &lock;
io.lockx.in.file.fnum = fd;
status = smb_raw_lock(cli->tree, &io);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Unlock failed\n"));
exit(1);
}
}
static void write_byte(struct smbcli_state *cli, int fd, uint8_t c, int offset)
{
union smb_write io;
NTSTATUS status;
io.generic.level = RAW_WRITE_WRITEX;
io.writex.in.file.fnum = fd;
io.writex.in.offset = offset;
io.writex.in.wmode = 0;
io.writex.in.remaining = 0;
io.writex.in.count = 1;
io.writex.in.data = &c;
status = smb_raw_write(cli->tree, &io);
if (!NT_STATUS_IS_OK(status)) {
printf("write failed\n");
exit(1);
}
}
static void read_byte(struct smbcli_state *cli, int fd, uint8_t *c, int offset)
{
union smb_read io;
NTSTATUS status;
io.generic.level = RAW_READ_READX;
io.readx.in.file.fnum = fd;
io.readx.in.mincnt = 1;
io.readx.in.maxcnt = 1;
io.readx.in.offset = offset;
io.readx.in.remaining = 0;
io.readx.in.read_for_execute = false;
io.readx.out.data = c;
status = smb_raw_read(cli->tree, &io);
if (!NT_STATUS_IS_OK(status)) {
printf("read failed\n");
exit(1);
}
}
/*
ping pong
*/
bool torture_ping_pong(struct torture_context *torture)
{
const char *fn;
int num_locks;
TALLOC_CTX *mem_ctx = talloc_new(torture);
static bool do_reads;
static bool do_writes;
int lock_timeout;
int fd;
struct smbcli_state *cli;
int i;
uint8_t incr=0, last_incr=0;
uint8_t *val;
int count, loops;
struct timeval start;
fn = torture_setting_string(torture, "filename", NULL);
if (fn == NULL) {
DEBUG(0,("You must specify the filename using --option=torture:filename=...\n"));
return false;
}
num_locks = torture_setting_int(torture, "num_locks", -1);
if (num_locks == -1) {
DEBUG(0,("You must specify num_locks using --option=torture:num_locks=...\n"));
return false;
}
do_reads = torture_setting_bool(torture, "read", false);
do_writes = torture_setting_bool(torture, "write", false);
lock_timeout = torture_setting_int(torture, "lock_timeout", 100000);
if (!torture_open_connection(&cli, torture, 0)) {
DEBUG(0,("Could not open connection\n"));
return false;
}
fd = smbcli_open(cli->tree, fn, O_RDWR|O_CREAT, DENY_NONE);
if (fd == -1) {
printf("Failed to open %s\n", fn);
exit(1);
}
write_byte(cli, fd, 0, num_locks);
lock_byte(cli, fd, 0, lock_timeout);
start = timeval_current();
val = talloc_zero_array(mem_ctx, uint8_t, num_locks);
i = 0;
count = 0;
loops = 0;
while (1) {
lock_byte(cli, fd, (i+1)%num_locks, lock_timeout);
if (do_reads) {
uint8_t c;
read_byte(cli, fd, &c, i);
incr = c-val[i];
val[i] = c;
}
if (do_writes) {
uint8_t c = val[i] + 1;
write_byte(cli, fd, c, i);
}
unlock_byte(cli, fd, i);
i = (i+1)%num_locks;
count++;
if (loops>num_locks && incr!=last_incr) {
last_incr = incr;
printf("data increment = %u\n", incr);
fflush(stdout);
}
if (timeval_elapsed(&start) > 1.0) {
printf("%8u locks/sec\r",
(unsigned)(2*count/timeval_elapsed(&start)));
fflush(stdout);
start = timeval_current();
count=0;
}
loops++;
}
}
| gpl-3.0 |
ncliam/serverpos | openerp/addons/hr_holidays/hr_holidays.py | 34256 | # -*- coding: utf-8 -*-
##################################################################################
#
# Copyright (c) 2005-2006 Axelor SARL. (http://www.axelor.com)
# and 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# $Id: hr.py 4656 2006-11-24 09:58:42Z Cyp $
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import datetime
import math
import time
from operator import attrgetter
from openerp.exceptions import Warning
from openerp import tools
from openerp.osv import fields, osv
from openerp.tools.translate import _
class hr_holidays_status(osv.osv):
_name = "hr.holidays.status"
_description = "Leave Type"
def get_days(self, cr, uid, ids, employee_id, context=None):
result = dict((id, dict(max_leaves=0, leaves_taken=0, remaining_leaves=0,
virtual_remaining_leaves=0)) for id in ids)
holiday_ids = self.pool['hr.holidays'].search(cr, uid, [('employee_id', '=', employee_id),
('state', 'in', ['confirm', 'validate1', 'validate']),
('holiday_status_id', 'in', ids)
], context=context)
for holiday in self.pool['hr.holidays'].browse(cr, uid, holiday_ids, context=context):
status_dict = result[holiday.holiday_status_id.id]
if holiday.type == 'add':
status_dict['virtual_remaining_leaves'] += holiday.number_of_days_temp
if holiday.state == 'validate':
status_dict['max_leaves'] += holiday.number_of_days_temp
status_dict['remaining_leaves'] += holiday.number_of_days_temp
elif holiday.type == 'remove': # number of days is negative
status_dict['virtual_remaining_leaves'] -= holiday.number_of_days_temp
if holiday.state == 'validate':
status_dict['leaves_taken'] += holiday.number_of_days_temp
status_dict['remaining_leaves'] -= holiday.number_of_days_temp
return result
def _user_left_days(self, cr, uid, ids, name, args, context=None):
employee_id = False
if context and 'employee_id' in context:
employee_id = context['employee_id']
else:
employee_ids = self.pool.get('hr.employee').search(cr, uid, [('user_id', '=', uid)], context=context)
if employee_ids:
employee_id = employee_ids[0]
if employee_id:
res = self.get_days(cr, uid, ids, employee_id, context=context)
else:
res = dict((res_id, {'leaves_taken': 0, 'remaining_leaves': 0, 'max_leaves': 0}) for res_id in ids)
return res
_columns = {
'name': fields.char('Leave Type', size=64, required=True, translate=True),
'categ_id': fields.many2one('calendar.event.type', 'Meeting Type',
help='Once a leave is validated, Odoo will create a corresponding meeting of this type in the calendar.'),
'color_name': fields.selection([('red', 'Red'),('blue','Blue'), ('lightgreen', 'Light Green'), ('lightblue','Light Blue'), ('lightyellow', 'Light Yellow'), ('magenta', 'Magenta'),('lightcyan', 'Light Cyan'),('black', 'Black'),('lightpink', 'Light Pink'),('brown', 'Brown'),('violet', 'Violet'),('lightcoral', 'Light Coral'),('lightsalmon', 'Light Salmon'),('lavender', 'Lavender'),('wheat', 'Wheat'),('ivory', 'Ivory')],'Color in Report', required=True, help='This color will be used in the leaves summary located in Reporting\Leaves by Department.'),
'limit': fields.boolean('Allow to Override Limit', help='If you select this check box, the system allows the employees to take more leaves than the available ones for this type and will not take them into account for the "Remaining Legal Leaves" defined on the employee form.'),
'active': fields.boolean('Active', help="If the active field is set to false, it will allow you to hide the leave type without removing it."),
'max_leaves': fields.function(_user_left_days, string='Maximum Allowed', help='This value is given by the sum of all holidays requests with a positive value.', multi='user_left_days'),
'leaves_taken': fields.function(_user_left_days, string='Leaves Already Taken', help='This value is given by the sum of all holidays requests with a negative value.', multi='user_left_days'),
'remaining_leaves': fields.function(_user_left_days, string='Remaining Leaves', help='Maximum Leaves Allowed - Leaves Already Taken', multi='user_left_days'),
'virtual_remaining_leaves': fields.function(_user_left_days, string='Virtual Remaining Leaves', help='Maximum Leaves Allowed - Leaves Already Taken - Leaves Waiting Approval', multi='user_left_days'),
'double_validation': fields.boolean('Apply Double Validation', help="When selected, the Allocation/Leave Requests for this type require a second validation to be approved."),
}
_defaults = {
'color_name': 'red',
'active': True,
}
def name_get(self, cr, uid, ids, context=None):
if context is None:
context = {}
if not context.get('employee_id',False):
# leave counts is based on employee_id, would be inaccurate if not based on correct employee
return super(hr_holidays_status, self).name_get(cr, uid, ids, context=context)
res = []
for record in self.browse(cr, uid, ids, context=context):
name = record.name
if not record.limit:
name = name + (' (%g/%g)' % (record.leaves_taken or 0.0, record.max_leaves or 0.0))
res.append((record.id, name))
return res
class hr_holidays(osv.osv):
_name = "hr.holidays"
_description = "Leave"
_order = "type desc, date_from asc"
_inherit = ['mail.thread', 'ir.needaction_mixin']
_track = {
'state': {
'hr_holidays.mt_holidays_approved': lambda self, cr, uid, obj, ctx=None: obj.state == 'validate',
'hr_holidays.mt_holidays_refused': lambda self, cr, uid, obj, ctx=None: obj.state == 'refuse',
'hr_holidays.mt_holidays_confirmed': lambda self, cr, uid, obj, ctx=None: obj.state == 'confirm',
},
}
def _employee_get(self, cr, uid, context=None):
emp_id = context.get('default_employee_id', False)
if emp_id:
return emp_id
ids = self.pool.get('hr.employee').search(cr, uid, [('user_id', '=', uid)], context=context)
if ids:
return ids[0]
return False
def _compute_number_of_days(self, cr, uid, ids, name, args, context=None):
result = {}
for hol in self.browse(cr, uid, ids, context=context):
if hol.type=='remove':
result[hol.id] = -hol.number_of_days_temp
else:
result[hol.id] = hol.number_of_days_temp
return result
def _get_can_reset(self, cr, uid, ids, name, arg, context=None):
"""User can reset a leave request if it is its own leave request or if
he is an Hr Manager. """
user = self.pool['res.users'].browse(cr, uid, uid, context=context)
group_hr_manager_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'base', 'group_hr_manager')[1]
if group_hr_manager_id in [g.id for g in user.groups_id]:
return dict.fromkeys(ids, True)
result = dict.fromkeys(ids, False)
for holiday in self.browse(cr, uid, ids, context=context):
if holiday.employee_id and holiday.employee_id.user_id and holiday.employee_id.user_id.id == uid:
result[holiday.id] = True
return result
def _check_date(self, cr, uid, ids, context=None):
for holiday in self.browse(cr, uid, ids, context=context):
domain = [
('date_from', '<=', holiday.date_to),
('date_to', '>=', holiday.date_from),
('employee_id', '=', holiday.employee_id.id),
('id', '!=', holiday.id),
('state', 'not in', ['cancel', 'refuse']),
]
nholidays = self.search_count(cr, uid, domain, context=context)
if nholidays:
return False
return True
_check_holidays = lambda self, cr, uid, ids, context=None: self.check_holidays(cr, uid, ids, context=context)
_columns = {
'name': fields.char('Description', size=64),
'state': fields.selection([('draft', 'To Submit'), ('cancel', 'Cancelled'),('confirm', 'To Approve'), ('refuse', 'Refused'), ('validate1', 'Second Approval'), ('validate', 'Approved')],
'Status', readonly=True, track_visibility='onchange', copy=False,
help='The status is set to \'To Submit\', when a holiday request is created.\
\nThe status is \'To Approve\', when holiday request is confirmed by user.\
\nThe status is \'Refused\', when holiday request is refused by manager.\
\nThe status is \'Approved\', when holiday request is approved by manager.'),
'user_id':fields.related('employee_id', 'user_id', type='many2one', relation='res.users', string='User', store=True),
'date_from': fields.datetime('Start Date', readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}, select=True, copy=False),
'date_to': fields.datetime('End Date', readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}, copy=False),
'holiday_status_id': fields.many2one("hr.holidays.status", "Leave Type", required=True,readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}),
'employee_id': fields.many2one('hr.employee', "Employee", select=True, invisible=False, readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}),
'manager_id': fields.many2one('hr.employee', 'First Approval', invisible=False, readonly=True, copy=False,
help='This area is automatically filled by the user who validate the leave'),
'notes': fields.text('Reasons',readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}),
'number_of_days_temp': fields.float('Allocation', readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}, copy=False),
'number_of_days': fields.function(_compute_number_of_days, string='Number of Days', store=True),
'meeting_id': fields.many2one('calendar.event', 'Meeting'),
'type': fields.selection([('remove','Leave Request'),('add','Allocation Request')], 'Request Type', required=True, readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}, help="Choose 'Leave Request' if someone wants to take an off-day. \nChoose 'Allocation Request' if you want to increase the number of leaves available for someone", select=True),
'parent_id': fields.many2one('hr.holidays', 'Parent'),
'linked_request_ids': fields.one2many('hr.holidays', 'parent_id', 'Linked Requests',),
'department_id':fields.related('employee_id', 'department_id', string='Department', type='many2one', relation='hr.department', readonly=True, store=True),
'category_id': fields.many2one('hr.employee.category', "Employee Tag", help='Category of Employee', readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}),
'holiday_type': fields.selection([('employee','By Employee'),('category','By Employee Tag')], 'Allocation Mode', readonly=True, states={'draft':[('readonly',False)], 'confirm':[('readonly',False)]}, help='By Employee: Allocation/Request for individual Employee, By Employee Tag: Allocation/Request for group of employees in category', required=True),
'manager_id2': fields.many2one('hr.employee', 'Second Approval', readonly=True, copy=False,
help='This area is automaticly filled by the user who validate the leave with second level (If Leave type need second validation)'),
'double_validation': fields.related('holiday_status_id', 'double_validation', type='boolean', relation='hr.holidays.status', string='Apply Double Validation'),
'can_reset': fields.function(
_get_can_reset,
type='boolean'),
}
_defaults = {
'employee_id': _employee_get,
'state': 'confirm',
'type': 'remove',
'user_id': lambda obj, cr, uid, context: uid,
'holiday_type': 'employee'
}
_constraints = [
(_check_date, 'You can not have 2 leaves that overlaps on same day!', ['date_from','date_to']),
(_check_holidays, 'The number of remaining leaves is not sufficient for this leave type', ['state','number_of_days_temp'])
]
_sql_constraints = [
('type_value', "CHECK( (holiday_type='employee' AND employee_id IS NOT NULL) or (holiday_type='category' AND category_id IS NOT NULL))",
"The employee or employee category of this request is missing. Please make sure that your user login is linked to an employee."),
('date_check2', "CHECK ( (type='add') OR (date_from <= date_to))", "The start date must be anterior to the end date."),
('date_check', "CHECK ( number_of_days_temp >= 0 )", "The number of days must be greater than 0."),
]
def _create_resource_leave(self, cr, uid, leaves, context=None):
'''This method will create entry in resource calendar leave object at the time of holidays validated '''
obj_res_leave = self.pool.get('resource.calendar.leaves')
for leave in leaves:
vals = {
'name': leave.name,
'date_from': leave.date_from,
'holiday_id': leave.id,
'date_to': leave.date_to,
'resource_id': leave.employee_id.resource_id.id,
'calendar_id': leave.employee_id.resource_id.calendar_id.id
}
obj_res_leave.create(cr, uid, vals, context=context)
return True
def _remove_resource_leave(self, cr, uid, ids, context=None):
'''This method will create entry in resource calendar leave object at the time of holidays cancel/removed'''
obj_res_leave = self.pool.get('resource.calendar.leaves')
leave_ids = obj_res_leave.search(cr, uid, [('holiday_id', 'in', ids)], context=context)
return obj_res_leave.unlink(cr, uid, leave_ids, context=context)
def onchange_type(self, cr, uid, ids, holiday_type, employee_id=False, context=None):
result = {}
if holiday_type == 'employee' and not employee_id:
ids_employee = self.pool.get('hr.employee').search(cr, uid, [('user_id','=', uid)])
if ids_employee:
result['value'] = {
'employee_id': ids_employee[0]
}
elif holiday_type != 'employee':
result['value'] = {
'employee_id': False
}
return result
def onchange_employee(self, cr, uid, ids, employee_id):
result = {'value': {'department_id': False}}
if employee_id:
employee = self.pool.get('hr.employee').browse(cr, uid, employee_id)
result['value'] = {'department_id': employee.department_id.id}
return result
# TODO: can be improved using resource calendar method
def _get_number_of_days(self, date_from, date_to):
"""Returns a float equals to the timedelta between two dates given as string."""
DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
from_dt = datetime.datetime.strptime(date_from, DATETIME_FORMAT)
to_dt = datetime.datetime.strptime(date_to, DATETIME_FORMAT)
timedelta = to_dt - from_dt
diff_day = timedelta.days + float(timedelta.seconds) / 86400
return diff_day
def unlink(self, cr, uid, ids, context=None):
for rec in self.browse(cr, uid, ids, context=context):
if rec.state not in ['draft', 'cancel', 'confirm']:
raise osv.except_osv(_('Warning!'),_('You cannot delete a leave which is in %s state.')%(rec.state))
return super(hr_holidays, self).unlink(cr, uid, ids, context)
def onchange_date_from(self, cr, uid, ids, date_to, date_from):
"""
If there are no date set for date_to, automatically set one 8 hours later than
the date_from.
Also update the number_of_days.
"""
# date_to has to be greater than date_from
if (date_from and date_to) and (date_from > date_to):
raise osv.except_osv(_('Warning!'),_('The start date must be anterior to the end date.'))
result = {'value': {}}
# No date_to set so far: automatically compute one 8 hours later
if date_from and not date_to:
date_to_with_delta = datetime.datetime.strptime(date_from, tools.DEFAULT_SERVER_DATETIME_FORMAT) + datetime.timedelta(hours=8)
result['value']['date_to'] = str(date_to_with_delta)
# Compute and update the number of days
if (date_to and date_from) and (date_from <= date_to):
diff_day = self._get_number_of_days(date_from, date_to)
result['value']['number_of_days_temp'] = round(math.floor(diff_day))+1
else:
result['value']['number_of_days_temp'] = 0
return result
def onchange_date_to(self, cr, uid, ids, date_to, date_from):
"""
Update the number_of_days.
"""
# date_to has to be greater than date_from
if (date_from and date_to) and (date_from > date_to):
raise osv.except_osv(_('Warning!'),_('The start date must be anterior to the end date.'))
result = {'value': {}}
# Compute and update the number of days
if (date_to and date_from) and (date_from <= date_to):
diff_day = self._get_number_of_days(date_from, date_to)
result['value']['number_of_days_temp'] = round(math.floor(diff_day))+1
else:
result['value']['number_of_days_temp'] = 0
return result
def add_follower(self, cr, uid, ids, employee_id, context=None):
employee = self.pool['hr.employee'].browse(cr, uid, employee_id, context=context)
if employee.user_id:
self.message_subscribe(cr, uid, ids, [employee.user_id.partner_id.id], context=context)
def create(self, cr, uid, values, context=None):
""" Override to avoid automatic logging of creation """
if context is None:
context = {}
employee_id = values.get('employee_id', False)
context = dict(context, mail_create_nolog=True, mail_create_nosubscribe=True)
if values.get('state') and values['state'] not in ['draft', 'confirm', 'cancel'] and not self.pool['res.users'].has_group(cr, uid, 'base.group_hr_user'):
raise osv.except_osv(_('Warning!'), _('You cannot set a leave request as \'%s\'. Contact a human resource manager.') % values.get('state'))
hr_holiday_id = super(hr_holidays, self).create(cr, uid, values, context=context)
self.add_follower(cr, uid, [hr_holiday_id], employee_id, context=context)
return hr_holiday_id
def write(self, cr, uid, ids, vals, context=None):
employee_id = vals.get('employee_id', False)
if vals.get('state') and vals['state'] not in ['draft', 'confirm', 'cancel'] and not self.pool['res.users'].has_group(cr, uid, 'base.group_hr_user'):
raise osv.except_osv(_('Warning!'), _('You cannot set a leave request as \'%s\'. Contact a human resource manager.') % vals.get('state'))
hr_holiday_id = super(hr_holidays, self).write(cr, uid, ids, vals, context=context)
self.add_follower(cr, uid, ids, employee_id, context=context)
return hr_holiday_id
def holidays_reset(self, cr, uid, ids, context=None):
self.write(cr, uid, ids, {
'state': 'draft',
'manager_id': False,
'manager_id2': False,
})
to_unlink = []
for record in self.browse(cr, uid, ids, context=context):
for record2 in record.linked_request_ids:
self.holidays_reset(cr, uid, [record2.id], context=context)
to_unlink.append(record2.id)
if to_unlink:
self.unlink(cr, uid, to_unlink, context=context)
return True
def holidays_first_validate(self, cr, uid, ids, context=None):
obj_emp = self.pool.get('hr.employee')
ids2 = obj_emp.search(cr, uid, [('user_id', '=', uid)])
manager = ids2 and ids2[0] or False
self.holidays_first_validate_notificate(cr, uid, ids, context=context)
return self.write(cr, uid, ids, {'state':'validate1', 'manager_id': manager})
def holidays_validate(self, cr, uid, ids, context=None):
obj_emp = self.pool.get('hr.employee')
ids2 = obj_emp.search(cr, uid, [('user_id', '=', uid)])
manager = ids2 and ids2[0] or False
self.write(cr, uid, ids, {'state':'validate'})
data_holiday = self.browse(cr, uid, ids)
for record in data_holiday:
if record.double_validation:
self.write(cr, uid, [record.id], {'manager_id2': manager})
else:
self.write(cr, uid, [record.id], {'manager_id': manager})
if record.holiday_type == 'employee' and record.type == 'remove':
meeting_obj = self.pool.get('calendar.event')
meeting_vals = {
'name': record.name or _('Leave Request'),
'categ_ids': record.holiday_status_id.categ_id and [(6,0,[record.holiday_status_id.categ_id.id])] or [],
'duration': record.number_of_days_temp * 8,
'description': record.notes,
'user_id': record.user_id.id,
'start': record.date_from,
'stop': record.date_to,
'allday': False,
'state': 'open', # to block that meeting date in the calendar
'class': 'confidential'
}
#Add the partner_id (if exist) as an attendee
if record.user_id and record.user_id.partner_id:
meeting_vals['partner_ids'] = [(4,record.user_id.partner_id.id)]
ctx_no_email = dict(context or {}, no_email=True)
meeting_id = meeting_obj.create(cr, uid, meeting_vals, context=ctx_no_email)
self._create_resource_leave(cr, uid, [record], context=context)
self.write(cr, uid, ids, {'meeting_id': meeting_id})
elif record.holiday_type == 'category':
emp_ids = obj_emp.search(cr, uid, [('category_ids', 'child_of', [record.category_id.id])])
leave_ids = []
batch_context = dict(context, mail_notify_force_send=False)
for emp in obj_emp.browse(cr, uid, emp_ids, context=context):
vals = {
'name': record.name,
'type': record.type,
'holiday_type': 'employee',
'holiday_status_id': record.holiday_status_id.id,
'date_from': record.date_from,
'date_to': record.date_to,
'notes': record.notes,
'number_of_days_temp': record.number_of_days_temp,
'parent_id': record.id,
'employee_id': emp.id
}
leave_ids.append(self.create(cr, uid, vals, context=batch_context))
for leave_id in leave_ids:
# TODO is it necessary to interleave the calls?
for sig in ('confirm', 'validate', 'second_validate'):
self.signal_workflow(cr, uid, [leave_id], sig)
return True
def holidays_confirm(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids, context=context):
if record.employee_id and record.employee_id.parent_id and record.employee_id.parent_id.user_id:
self.message_subscribe_users(cr, uid, [record.id], user_ids=[record.employee_id.parent_id.user_id.id], context=context)
return self.write(cr, uid, ids, {'state': 'confirm'})
def holidays_refuse(self, cr, uid, ids, context=None):
obj_emp = self.pool.get('hr.employee')
ids2 = obj_emp.search(cr, uid, [('user_id', '=', uid)])
manager = ids2 and ids2[0] or False
for holiday in self.browse(cr, uid, ids, context=context):
if holiday.state == 'validate1':
self.write(cr, uid, [holiday.id], {'state': 'refuse', 'manager_id': manager})
else:
self.write(cr, uid, [holiday.id], {'state': 'refuse', 'manager_id2': manager})
self.holidays_cancel(cr, uid, ids, context=context)
return True
def holidays_cancel(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids, context=context):
# Delete the meeting
if record.meeting_id:
record.meeting_id.unlink()
# If a category that created several holidays, cancel all related
self.signal_workflow(cr, uid, map(attrgetter('id'), record.linked_request_ids or []), 'refuse')
self._remove_resource_leave(cr, uid, ids, context=context)
return True
def check_holidays(self, cr, uid, ids, context=None):
for record in self.browse(cr, uid, ids, context=context):
if record.holiday_type != 'employee' or record.type != 'remove' or not record.employee_id or record.holiday_status_id.limit:
continue
leave_days = self.pool.get('hr.holidays.status').get_days(cr, uid, [record.holiday_status_id.id], record.employee_id.id, context=context)[record.holiday_status_id.id]
if leave_days['remaining_leaves'] < 0 or leave_days['virtual_remaining_leaves'] < 0:
# Raising a warning gives a more user-friendly feedback than the default constraint error
raise Warning(_('The number of remaining leaves is not sufficient for this leave type.\n'
'Please verify also the leaves waiting for validation.'))
return True
# -----------------------------
# OpenChatter and notifications
# -----------------------------
def _needaction_domain_get(self, cr, uid, context=None):
emp_obj = self.pool.get('hr.employee')
empids = emp_obj.search(cr, uid, [('parent_id.user_id', '=', uid)], context=context)
dom = ['&', ('state', '=', 'confirm'), ('employee_id', 'in', empids)]
# if this user is a hr.manager, he should do second validations
if self.pool.get('res.users').has_group(cr, uid, 'base.group_hr_manager'):
dom = ['|'] + dom + [('state', '=', 'validate1')]
return dom
def holidays_first_validate_notificate(self, cr, uid, ids, context=None):
for obj in self.browse(cr, uid, ids, context=context):
self.message_post(cr, uid, [obj.id],
_("Request approved, waiting second validation."), context=context)
class resource_calendar_leaves(osv.osv):
_inherit = "resource.calendar.leaves"
_description = "Leave Detail"
_columns = {
'holiday_id': fields.many2one("hr.holidays", "Leave Request"),
}
class hr_employee(osv.osv):
_inherit="hr.employee"
def create(self, cr, uid, vals, context=None):
# don't pass the value of remaining leave if it's 0 at the creation time, otherwise it will trigger the inverse
# function _set_remaining_days and the system may not be configured for. Note that we don't have this problem on
# the write because the clients only send the fields that have been modified.
if 'remaining_leaves' in vals and not vals['remaining_leaves']:
del(vals['remaining_leaves'])
return super(hr_employee, self).create(cr, uid, vals, context=context)
def _set_remaining_days(self, cr, uid, empl_id, name, value, arg, context=None):
employee = self.browse(cr, uid, empl_id, context=context)
diff = value - employee.remaining_leaves
type_obj = self.pool.get('hr.holidays.status')
holiday_obj = self.pool.get('hr.holidays')
# Find for holidays status
status_ids = type_obj.search(cr, uid, [('limit', '=', False)], context=context)
if len(status_ids) != 1 :
raise osv.except_osv(_('Warning!'),_("The feature behind the field 'Remaining Legal Leaves' can only be used when there is only one leave type with the option 'Allow to Override Limit' unchecked. (%s Found). Otherwise, the update is ambiguous as we cannot decide on which leave type the update has to be done. \nYou may prefer to use the classic menus 'Leave Requests' and 'Allocation Requests' located in 'Human Resources \ Leaves' to manage the leave days of the employees if the configuration does not allow to use this field.") % (len(status_ids)))
status_id = status_ids and status_ids[0] or False
if not status_id:
return False
if diff > 0:
leave_id = holiday_obj.create(cr, uid, {'name': _('Allocation for %s') % employee.name, 'employee_id': employee.id, 'holiday_status_id': status_id, 'type': 'add', 'holiday_type': 'employee', 'number_of_days_temp': diff}, context=context)
elif diff < 0:
raise osv.except_osv(_('Warning!'), _('You cannot reduce validated allocation requests'))
else:
return False
for sig in ('confirm', 'validate', 'second_validate'):
holiday_obj.signal_workflow(cr, uid, [leave_id], sig)
return True
def _get_remaining_days(self, cr, uid, ids, name, args, context=None):
cr.execute("""SELECT
sum(h.number_of_days) as days,
h.employee_id
from
hr_holidays h
join hr_holidays_status s on (s.id=h.holiday_status_id)
where
h.state='validate' and
s.limit=False and
h.employee_id in %s
group by h.employee_id""", (tuple(ids),))
res = cr.dictfetchall()
remaining = {}
for r in res:
remaining[r['employee_id']] = r['days']
for employee_id in ids:
if not remaining.get(employee_id):
remaining[employee_id] = 0.0
return remaining
def _get_leave_status(self, cr, uid, ids, name, args, context=None):
holidays_obj = self.pool.get('hr.holidays')
holidays_id = holidays_obj.search(cr, uid,
[('employee_id', 'in', ids), ('date_from','<=',time.strftime('%Y-%m-%d %H:%M:%S')),
('date_to','>=',time.strftime('%Y-%m-%d 23:59:59')),('type','=','remove'),('state','not in',('cancel','refuse'))],
context=context)
result = {}
for id in ids:
result[id] = {
'current_leave_state': False,
'current_leave_id': False,
'leave_date_from':False,
'leave_date_to':False,
}
for holiday in self.pool.get('hr.holidays').browse(cr, uid, holidays_id, context=context):
result[holiday.employee_id.id]['leave_date_from'] = holiday.date_from
result[holiday.employee_id.id]['leave_date_to'] = holiday.date_to
result[holiday.employee_id.id]['current_leave_state'] = holiday.state
result[holiday.employee_id.id]['current_leave_id'] = holiday.holiday_status_id.id
return result
def _leaves_count(self, cr, uid, ids, field_name, arg, context=None):
Holidays = self.pool['hr.holidays']
return {
employee_id: Holidays.search_count(cr,uid, [('employee_id', '=', employee_id), ('type', '=', 'remove')], context=context)
for employee_id in ids
}
_columns = {
'remaining_leaves': fields.function(_get_remaining_days, string='Remaining Legal Leaves', fnct_inv=_set_remaining_days, type="float", help='Total number of legal leaves allocated to this employee, change this value to create allocation/leave request. Total based on all the leave types without overriding limit.'),
'current_leave_state': fields.function(_get_leave_status, multi="leave_status", string="Current Leave Status", type="selection",
selection=[('draft', 'New'), ('confirm', 'Waiting Approval'), ('refuse', 'Refused'),
('validate1', 'Waiting Second Approval'), ('validate', 'Approved'), ('cancel', 'Cancelled')]),
'current_leave_id': fields.function(_get_leave_status, multi="leave_status", string="Current Leave Type",type='many2one', relation='hr.holidays.status'),
'leave_date_from': fields.function(_get_leave_status, multi='leave_status', type='date', string='From Date'),
'leave_date_to': fields.function(_get_leave_status, multi='leave_status', type='date', string='To Date'),
'leaves_count': fields.function(_leaves_count, type='integer', string='Leaves'),
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
| agpl-3.0 |
ChangezKhan/SuiteCRM | include/connectors/filters/default/filter.php | 3456 | <?php
/**
*
* SugarCRM Community Edition is a customer relationship management program developed by
* SugarCRM, Inc. Copyright (C) 2004-2013 SugarCRM Inc.
*
* SuiteCRM is an extension to SugarCRM Community Edition developed by SalesAgility Ltd.
* Copyright (C) 2011 - 2018 SalesAgility Ltd.
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU Affero General Public License version 3 as published by the
* Free Software Foundation with the addition of the following permission added
* to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED WORK
* IN WHICH THE COPYRIGHT IS OWNED BY SUGARCRM, SUGARCRM DISCLAIMS THE WARRANTY
* OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
* details.
*
* You should have received a copy of the GNU Affero General Public License along with
* this program; if not, see http://www.gnu.org/licenses or write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA.
*
* You can contact SugarCRM, Inc. headquarters at 10050 North Wolfe Road,
* SW2-130, Cupertino, CA 95014, USA. or at email address [email protected].
*
* The interactive user interfaces in modified source and object code versions
* of this program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU Affero General Public License version 3.
*
* In accordance with Section 7(b) of the GNU Affero General Public License version 3,
* these Appropriate Legal Notices must retain the display of the "Powered by
* SugarCRM" logo and "Supercharged by SuiteCRM" logo. If the display of the logos is not
* reasonably feasible for technical reasons, the Appropriate Legal Notices must
* display the words "Powered by SugarCRM" and "Supercharged by SuiteCRM".
*/
/**
* Generic filter
* @api
*/
class default_filter
{
public $_component;
public function __construct()
{
}
/**
* @deprecated deprecated since version 7.6, PHP4 Style Constructors are deprecated and will be remove in 7.8, please update your code, use __construct instead
*/
public function default_filter()
{
$deprecatedMessage = 'PHP4 Style Constructors are deprecated and will be remove in 7.8, please update your code';
if (isset($GLOBALS['log'])) {
$GLOBALS['log']->deprecated($deprecatedMessage);
} else {
trigger_error($deprecatedMessage, E_USER_DEPRECATED);
}
self::__construct();
}
public function setComponent($component)
{
$this->_component = $component;
}
/**
* getList
* Returns a nested array containing a key/value pair(s) of a source record
*
* @param array $args Array of arguments to search/filter by
* @param string $module String optional value of the module that the connector framework is attempting to map to
* @return array of key/value pair(s) of source record; empty Array if no results are found
*/
public function getList($args, $module)
{
$args = $this->_component->mapInput($args, $module);
return $this->_component->getSource()->getList($args, $module);
}
}
| agpl-3.0 |
Jtalk/kopete-fork-xep0136 | protocols/jabber/libiris/include/iris/im.h | 39 | #include "../../src/xmpp/xmpp-im/im.h"
| lgpl-2.1 |
johntfoster/dealii | tests/base/quadrature_test.cc | 6728 | // ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------
// check accuracy of various quadrature formulas by using them to
// integrate polynomials of increasing degree, and finding the degree
// until which they integrate exactly
#include "../tests.h"
#include <iomanip>
#include <fstream>
#include <deal.II/base/logstream.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/qprojector.h>
#include <cmath>
template <int dim>
void
fill_vector (std::vector<Quadrature<dim> *> &quadratures)
{
quadratures.push_back (new QMidpoint<dim>());
quadratures.push_back (new QTrapez<dim>());
quadratures.push_back (new QSimpson<dim>());
quadratures.push_back (new QMilne<dim>());
quadratures.push_back (new QWeddle<dim>());
for (unsigned int i=0; i<9; ++i)
{
quadratures.push_back (new QGauss<dim>(i));
}
QMilne<1> q1d;
quadratures.push_back (new Quadrature<dim>(q1d));
for (unsigned int i=2; i<8; ++i)
{
quadratures.push_back (new QGaussLobatto<dim>(i));
}
}
template <int dim>
void
check_cells (std::vector<Quadrature<dim>*> &quadratures)
{
Quadrature<dim> quadrature;
for (unsigned int n=0; n<quadratures.size(); ++n)
{
quadrature = *quadratures[n];
const std::vector<Point<dim> > &points=quadrature.get_points();
const std::vector<double> &weights=quadrature.get_weights();
deallog << "Quadrature no." << n;
unsigned int i=0;
double quadrature_int=0;
double exact_int=0;
double err = 0;
do
{
++i;
quadrature_int=0;
// Check the polynomial x^i*y^i
for (unsigned int x=0; x<quadrature.size(); ++x)
{
double f=1.;
switch (dim)
{
case 3:
f *= std::pow(static_cast<double>(points[x](2)), i*1.0);
case 2:
f *= std::pow(static_cast<double>(points[x](1)), i*1.0);
case 1:
f *= std::pow(static_cast<double>(points[x](0)), i*1.0);
}
quadrature_int+=f*weights[x];
}
// the exact integral is 1/(i+1)
exact_int=1./std::pow(static_cast<double>(i+1),dim);
err = std::fabs(quadrature_int-exact_int);
}
while (err<1e-14);
// Uncomment here for testing
// deallog << " (Int " << quadrature_int << ',' << exact_int << ")";
deallog << " is exact for polynomials of degree " << i-1 << std::endl;
if (dim==1)
{
// check the ordering of
// the quadrature points
bool in_order=true;
for (unsigned int x=1; x<quadrature.size(); ++x)
{
if (points[x](0)<=points[x-1](0))
in_order=false;
}
if (!in_order)
for (unsigned int x=0; x<quadrature.size(); ++x)
deallog << points[x] << std::endl;
}
}
}
template <int dim>
void
check_faces (const std::vector<Quadrature<dim-1>*>& quadratures, const bool sub)
{
if (sub)
deallog.push("subfaces");
else
deallog.push("faces");
for (unsigned int n=0; n<quadratures.size(); ++n)
{
Quadrature<dim> quadrature (sub == false?
QProjector<dim>::project_to_all_faces(*quadratures[n]) :
QProjector<dim>::project_to_all_subfaces(*quadratures[n]));
const std::vector<Point<dim> > &points=quadrature.get_points();
const std::vector<double> &weights=quadrature.get_weights();
deallog << "Quadrature no." << n;
unsigned int i=0;
long double quadrature_int=0;
double exact_int=0;
double err = 0;
do
{
++i;
quadrature_int=0;
// Check the polynomial
// x^i*y^i*z^i
for (unsigned int x=0; x<quadrature.size(); ++x)
{
long double f=1.;
switch (dim)
{
case 3:
f *= std::pow((long double) points[x](2), i*1.0L);
case 2:
f *= std::pow((long double) points[x](1), i*1.0L);
case 1:
f *= std::pow((long double) points[x](0), i*1.0L);
}
quadrature_int+=f*weights[x];
}
// the exact integral is
// 1/(i+1)^(dim-1)
switch (dim)
{
case 2:
exact_int = 2 * (sub ? 2:1) / (double) (i+1);
break;
case 3:
exact_int = 3 * (sub ? (4+2+2):1)*8 / (double) (i+1)/(i+1);
break;
}
err = std::fabs(quadrature_int-exact_int);
}
// for comparison: use factor 8 in case
// of dim==3, as we integrate 8 times
// over the whole surface (all
// combinations of face_orientation,
// face_flip and face_rotation)
while (err < (dim==3 ? 8 : 1) * 2e-14);
// Uncomment here for testing
// deallog << " (Int " << quadrature_int << '-' << exact_int << '=' << err << ")";
deallog << " is exact for polynomials of degree " << i-1 << std::endl;
}
deallog.pop();
}
int main()
{
std::ofstream logfile("output");
deallog.attach(logfile);
deallog.depth_console(0);
deallog.threshold_double(1.e-10);
std::vector<Quadrature<1> *> q1;
std::vector<Quadrature<2> *> q2;
std::vector<Quadrature<3> *> q3;
fill_vector (q1);
fill_vector (q2);
fill_vector (q3);
deallog.push("1d");
check_cells(q1);
deallog.pop();
deallog.push("2d");
check_cells(q2);
check_faces<2>(q1,false);
check_faces<2>(q1,true);
deallog.pop();
deallog.push("3d");
check_cells(q3);
check_faces<3>(q2,false);
check_faces<3>(q2,true);
deallog.pop();
// delete objects again to avoid
// messages about memory leaks when
// using purify or other memory
// checkers
for (unsigned int i=0; i<q1.size(); ++i)
delete q1[i];
for (unsigned int i=0; i<q2.size(); ++i)
delete q2[i];
for (unsigned int i=0; i<q3.size(); ++i)
delete q3[i];
}
| lgpl-2.1 |
natashasharma/dealii | tests/bits/cylinder_shell_01.cc | 1499 | // ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------
// test that the grid generated by GridGenerator::cylinder_shell<3> works as
// expected
#include "../tests.h"
#include <deal.II/base/logstream.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/grid_generator.h>
#include <fstream>
#include <iomanip>
int main ()
{
std::ofstream logfile("output");
deallog.attach(logfile);
deallog.depth_console(0);
deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
// generate a hyperball in 3d
Triangulation<3> tria;
GridGenerator::cylinder_shell (tria, 1, .8, 1);
// make sure that all cells have positive
// volume
for (Triangulation<3>::active_cell_iterator cell=tria.begin_active();
cell!=tria.end(); ++cell)
deallog << cell << ' ' << cell->measure () << std::endl;
}
| lgpl-2.1 |
jimczi/elasticsearch | core/src/test/java/org/elasticsearch/index/IndexingSlowLogTests.java | 13647 | /*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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 org.elasticsearch.index;
import org.apache.lucene.document.NumericDocValuesField;
import org.elasticsearch.Version;
import org.elasticsearch.cluster.metadata.IndexMetaData;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.elasticsearch.index.IndexingSlowLog.SlowLogParsedDocumentPrinter;
import org.elasticsearch.index.mapper.ParsedDocument;
import org.elasticsearch.index.mapper.SeqNoFieldMapper;
import org.elasticsearch.test.ESTestCase;
import java.io.IOException;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.hasToString;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.startsWith;
public class IndexingSlowLogTests extends ESTestCase {
public void testSlowLogParsedDocumentPrinterSourceToLog() throws IOException {
BytesReference source = JsonXContent.contentBuilder().startObject().field("foo", "bar").endObject().bytes();
ParsedDocument pd = new ParsedDocument(new NumericDocValuesField("version", 1), SeqNoFieldMapper.SequenceIDFields.emptySeqID(), "id",
"test", null, null, source, XContentType.JSON, null);
Index index = new Index("foo", "123");
// Turning off document logging doesn't log source[]
SlowLogParsedDocumentPrinter p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 0);
assertThat(p.toString(), not(containsString("source[")));
// Turning on document logging logs the whole thing
p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, Integer.MAX_VALUE);
assertThat(p.toString(), containsString("source[{\"foo\":\"bar\"}]"));
// And you can truncate the source
p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
assertThat(p.toString(), containsString("source[{\"f]"));
// And you can truncate the source
p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
assertThat(p.toString(), containsString("source[{\"f]"));
assertThat(p.toString(), startsWith("[foo/123] took"));
}
public void testReformatSetting() {
IndexMetaData metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_REFORMAT_SETTING.getKey(), false)
.build());
IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY);
IndexingSlowLog log = new IndexingSlowLog(settings);
assertFalse(log.isReformat());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_REFORMAT_SETTING.getKey(), "true").build()));
assertTrue(log.isReformat());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_REFORMAT_SETTING.getKey(), "false").build()));
assertFalse(log.isReformat());
settings.updateIndexMetaData(newIndexMeta("index", Settings.EMPTY));
assertTrue(log.isReformat());
metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.build());
settings = new IndexSettings(metaData, Settings.EMPTY);
log = new IndexingSlowLog(settings);
assertTrue(log.isReformat());
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_REFORMAT_SETTING.getKey(), "NOT A BOOLEAN").build()));
fail();
} catch (IllegalArgumentException ex) {
final String expected = "illegal value can't update [index.indexing.slowlog.reformat] from [true] to [NOT A BOOLEAN]";
assertThat(ex, hasToString(containsString(expected)));
assertNotNull(ex.getCause());
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
final IllegalArgumentException cause = (IllegalArgumentException) ex.getCause();
assertThat(cause, hasToString(containsString("Failed to parse value [NOT A BOOLEAN] as only [true] or [false] are allowed.")));
}
assertTrue(log.isReformat());
}
public void testLevelSetting() {
SlowLogLevel level = randomFrom(SlowLogLevel.values());
IndexMetaData metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_LEVEL_SETTING.getKey(), level)
.build());
IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY);
IndexingSlowLog log = new IndexingSlowLog(settings);
assertEquals(level, log.getLevel());
level = randomFrom(SlowLogLevel.values());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_LEVEL_SETTING.getKey(), level).build()));
assertEquals(level, log.getLevel());
level = randomFrom(SlowLogLevel.values());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_LEVEL_SETTING.getKey(), level).build()));
assertEquals(level, log.getLevel());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_LEVEL_SETTING.getKey(), level).build()));
assertEquals(level, log.getLevel());
settings.updateIndexMetaData(newIndexMeta("index", Settings.EMPTY));
assertEquals(SlowLogLevel.TRACE, log.getLevel());
metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.build());
settings = new IndexSettings(metaData, Settings.EMPTY);
log = new IndexingSlowLog(settings);
assertTrue(log.isReformat());
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_LEVEL_SETTING.getKey(), "NOT A LEVEL").build()));
fail();
} catch (IllegalArgumentException ex) {
final String expected = "illegal value can't update [index.indexing.slowlog.level] from [TRACE] to [NOT A LEVEL]";
assertThat(ex, hasToString(containsString(expected)));
assertNotNull(ex.getCause());
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
final IllegalArgumentException cause = (IllegalArgumentException) ex.getCause();
assertThat(cause, hasToString(containsString("No enum constant org.elasticsearch.index.SlowLogLevel.NOT A LEVEL")));
}
assertEquals(SlowLogLevel.TRACE, log.getLevel());
}
public void testSetLevels() {
IndexMetaData metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_TRACE_SETTING.getKey(), "100ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_DEBUG_SETTING.getKey(), "200ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_INFO_SETTING.getKey(), "300ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_WARN_SETTING.getKey(), "400ms")
.build());
IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY);
IndexingSlowLog log = new IndexingSlowLog(settings);
assertEquals(TimeValue.timeValueMillis(100).nanos(), log.getIndexTraceThreshold());
assertEquals(TimeValue.timeValueMillis(200).nanos(), log.getIndexDebugThreshold());
assertEquals(TimeValue.timeValueMillis(300).nanos(), log.getIndexInfoThreshold());
assertEquals(TimeValue.timeValueMillis(400).nanos(), log.getIndexWarnThreshold());
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_TRACE_SETTING.getKey(), "120ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_DEBUG_SETTING.getKey(), "220ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_INFO_SETTING.getKey(), "320ms")
.put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_WARN_SETTING.getKey(), "420ms").build()));
assertEquals(TimeValue.timeValueMillis(120).nanos(), log.getIndexTraceThreshold());
assertEquals(TimeValue.timeValueMillis(220).nanos(), log.getIndexDebugThreshold());
assertEquals(TimeValue.timeValueMillis(320).nanos(), log.getIndexInfoThreshold());
assertEquals(TimeValue.timeValueMillis(420).nanos(), log.getIndexWarnThreshold());
metaData = newIndexMeta("index", Settings.builder()
.put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.build());
settings.updateIndexMetaData(metaData);
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexTraceThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexDebugThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexInfoThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexWarnThreshold());
settings = new IndexSettings(metaData, Settings.EMPTY);
log = new IndexingSlowLog(settings);
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexTraceThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexDebugThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexInfoThreshold());
assertEquals(TimeValue.timeValueMillis(-1).nanos(), log.getIndexWarnThreshold());
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_TRACE_SETTING.getKey(), "NOT A TIME VALUE").build()));
fail();
} catch (IllegalArgumentException ex) {
assertTimeValueException(ex, "index.indexing.slowlog.threshold.index.trace");
}
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_DEBUG_SETTING.getKey(), "NOT A TIME VALUE").build()));
fail();
} catch (IllegalArgumentException ex) {
assertTimeValueException(ex, "index.indexing.slowlog.threshold.index.debug");
}
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_INFO_SETTING.getKey(), "NOT A TIME VALUE").build()));
fail();
} catch (IllegalArgumentException ex) {
assertTimeValueException(ex, "index.indexing.slowlog.threshold.index.info");
}
try {
settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(IndexingSlowLog.INDEX_INDEXING_SLOWLOG_THRESHOLD_INDEX_WARN_SETTING.getKey(), "NOT A TIME VALUE").build()));
fail();
} catch (IllegalArgumentException ex) {
assertTimeValueException(ex, "index.indexing.slowlog.threshold.index.warn");
}
}
private void assertTimeValueException(final IllegalArgumentException e, final String key) {
final String expected = "illegal value can't update [" + key + "] from [-1] to [NOT A TIME VALUE]";
assertThat(e, hasToString(containsString(expected)));
assertNotNull(e.getCause());
assertThat(e.getCause(), instanceOf(IllegalArgumentException.class));
final IllegalArgumentException cause = (IllegalArgumentException) e.getCause();
final String causeExpected =
"failed to parse setting [" + key + "] with value [NOT A TIME VALUE] as a time value: unit is missing or unrecognized";
assertThat(cause, hasToString(containsString(causeExpected)));
}
private IndexMetaData newIndexMeta(String name, Settings indexSettings) {
Settings build = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1)
.put(indexSettings)
.build();
IndexMetaData metaData = IndexMetaData.builder(name).settings(build).build();
return metaData;
}
}
| apache-2.0 |
livingbio/kubernetes | pkg/apiserver/handlers_test.go | 11099 | /*
Copyright 2014 The Kubernetes Authors All rights reserved.
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 apiserver
import (
"io/ioutil"
"net/http"
"net/http/httptest"
"reflect"
"regexp"
"strings"
"sync"
"testing"
"time"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/util/sets"
)
type fakeRL bool
func (fakeRL) Stop() {}
func (f fakeRL) CanAccept() bool { return bool(f) }
func (f fakeRL) Accept() {}
func expectHTTP(url string, code int, t *testing.T) {
r, err := http.Get(url)
if err != nil {
t.Errorf("unexpected error: %v", err)
return
}
if r.StatusCode != code {
t.Errorf("unexpected response: %v", r.StatusCode)
}
}
func getPath(resource, namespace, name string) string {
return testapi.Default.ResourcePath(resource, namespace, name)
}
func pathWithPrefix(prefix, resource, namespace, name string) string {
return testapi.Default.ResourcePathWithPrefix(prefix, resource, namespace, name)
}
func TestMaxInFlight(t *testing.T) {
const Iterations = 3
block := sync.WaitGroup{}
block.Add(1)
sem := make(chan bool, Iterations)
re := regexp.MustCompile("[.*\\/watch][^\\/proxy.*]")
// Calls verifies that the server is actually blocked up before running the rest of the test
calls := &sync.WaitGroup{}
calls.Add(Iterations * 3)
server := httptest.NewServer(MaxInFlightLimit(sem, re, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if strings.Contains(r.URL.Path, "dontwait") {
return
}
if calls != nil {
calls.Done()
}
block.Wait()
})))
defer server.Close()
// These should hang, but not affect accounting.
for i := 0; i < Iterations; i++ {
// These should hang waiting on block...
go func() {
expectHTTP(server.URL+"/foo/bar/watch", http.StatusOK, t)
}()
}
for i := 0; i < Iterations; i++ {
// These should hang waiting on block...
go func() {
expectHTTP(server.URL+"/proxy/foo/bar", http.StatusOK, t)
}()
}
expectHTTP(server.URL+"/dontwait", http.StatusOK, t)
for i := 0; i < Iterations; i++ {
// These should hang waiting on block...
go func() {
expectHTTP(server.URL, http.StatusOK, t)
}()
}
calls.Wait()
calls = nil
// Do this multiple times to show that it rate limit rejected requests don't block.
for i := 0; i < 2; i++ {
expectHTTP(server.URL, errors.StatusTooManyRequests, t)
}
// Validate that non-accounted URLs still work
expectHTTP(server.URL+"/dontwait/watch", http.StatusOK, t)
block.Done()
// Show that we recover from being blocked up.
expectHTTP(server.URL, http.StatusOK, t)
}
func TestReadOnly(t *testing.T) {
server := httptest.NewServer(ReadOnly(http.HandlerFunc(
func(w http.ResponseWriter, req *http.Request) {
if req.Method != "GET" {
t.Errorf("Unexpected call: %v", req.Method)
}
},
)))
defer server.Close()
for _, verb := range []string{"GET", "POST", "PUT", "DELETE", "CREATE"} {
req, err := http.NewRequest(verb, server.URL, nil)
if err != nil {
t.Fatalf("Couldn't make request: %v", err)
}
http.DefaultClient.Do(req)
}
}
func TestTimeout(t *testing.T) {
sendResponse := make(chan struct{}, 1)
writeErrors := make(chan error, 1)
timeout := make(chan time.Time, 1)
resp := "test response"
timeoutResp := "test timeout"
ts := httptest.NewServer(TimeoutHandler(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
<-sendResponse
_, err := w.Write([]byte(resp))
writeErrors <- err
}),
func(*http.Request) (<-chan time.Time, string) {
return timeout, timeoutResp
}))
defer ts.Close()
// No timeouts
sendResponse <- struct{}{}
res, err := http.Get(ts.URL)
if err != nil {
t.Error(err)
}
if res.StatusCode != http.StatusOK {
t.Errorf("got res.StatusCode %d; expected %d", res.StatusCode, http.StatusOK)
}
body, _ := ioutil.ReadAll(res.Body)
if string(body) != resp {
t.Errorf("got body %q; expected %q", string(body), resp)
}
if err := <-writeErrors; err != nil {
t.Errorf("got unexpected Write error on first request: %v", err)
}
// Times out
timeout <- time.Time{}
res, err = http.Get(ts.URL)
if err != nil {
t.Error(err)
}
if res.StatusCode != http.StatusGatewayTimeout {
t.Errorf("got res.StatusCode %d; expected %d", res.StatusCode, http.StatusServiceUnavailable)
}
body, _ = ioutil.ReadAll(res.Body)
if string(body) != timeoutResp {
t.Errorf("got body %q; expected %q", string(body), timeoutResp)
}
// Now try to send a response
sendResponse <- struct{}{}
if err := <-writeErrors; err != http.ErrHandlerTimeout {
t.Errorf("got Write error of %v; expected %v", err, http.ErrHandlerTimeout)
}
}
func TestGetAPIRequestInfo(t *testing.T) {
successCases := []struct {
method string
url string
expectedVerb string
expectedAPIVersion string
expectedNamespace string
expectedResource string
expectedSubresource string
expectedKind string
expectedName string
expectedParts []string
}{
// resource paths
{"GET", "/namespaces", "list", "", "", "namespaces", "", "Namespace", "", []string{"namespaces"}},
{"GET", "/namespaces/other", "get", "", "other", "namespaces", "", "Namespace", "other", []string{"namespaces", "other"}},
{"GET", "/namespaces/other/pods", "list", "", "other", "pods", "", "Pod", "", []string{"pods"}},
{"GET", "/namespaces/other/pods/foo", "get", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", "/pods", "list", "", api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"GET", "/namespaces/other/pods/foo", "get", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", "/namespaces/other/pods", "list", "", "other", "pods", "", "Pod", "", []string{"pods"}},
// special verbs
{"GET", "/proxy/namespaces/other/pods/foo", "proxy", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", "/redirect/namespaces/other/pods/foo", "redirect", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", "/watch/pods", "watch", "", api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"GET", "/watch/namespaces/other/pods", "watch", "", "other", "pods", "", "Pod", "", []string{"pods"}},
// fully-qualified paths
{"GET", getPath("pods", "other", ""), "list", testapi.Default.Version(), "other", "pods", "", "Pod", "", []string{"pods"}},
{"GET", getPath("pods", "other", "foo"), "get", testapi.Default.Version(), "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", getPath("pods", "", ""), "list", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"POST", getPath("pods", "", ""), "create", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"GET", getPath("pods", "", "foo"), "get", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", pathWithPrefix("proxy", "pods", "", "foo"), "proxy", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"GET", pathWithPrefix("watch", "pods", "", ""), "watch", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"GET", pathWithPrefix("redirect", "pods", "", ""), "redirect", testapi.Default.Version(), api.NamespaceAll, "pods", "", "Pod", "", []string{"pods"}},
{"GET", pathWithPrefix("watch", "pods", "other", ""), "watch", testapi.Default.Version(), "other", "pods", "", "Pod", "", []string{"pods"}},
// subresource identification
{"GET", "/namespaces/other/pods/foo/status", "get", "", "other", "pods", "status", "Pod", "foo", []string{"pods", "foo", "status"}},
{"PUT", "/namespaces/other/finalize", "update", "", "other", "finalize", "", "", "", []string{"finalize"}},
// verb identification
{"PATCH", "/namespaces/other/pods/foo", "patch", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
{"DELETE", "/namespaces/other/pods/foo", "delete", "", "other", "pods", "", "Pod", "foo", []string{"pods", "foo"}},
}
apiRequestInfoResolver := &APIRequestInfoResolver{sets.NewString("api"), testapi.Default.RESTMapper()}
for _, successCase := range successCases {
req, _ := http.NewRequest(successCase.method, successCase.url, nil)
apiRequestInfo, err := apiRequestInfoResolver.GetAPIRequestInfo(req)
if err != nil {
t.Errorf("Unexpected error for url: %s %v", successCase.url, err)
}
if successCase.expectedVerb != apiRequestInfo.Verb {
t.Errorf("Unexpected verb for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedVerb, apiRequestInfo.Verb)
}
if successCase.expectedAPIVersion != apiRequestInfo.APIVersion {
t.Errorf("Unexpected apiVersion for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedAPIVersion, apiRequestInfo.APIVersion)
}
if successCase.expectedNamespace != apiRequestInfo.Namespace {
t.Errorf("Unexpected namespace for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedNamespace, apiRequestInfo.Namespace)
}
if successCase.expectedKind != apiRequestInfo.Kind {
t.Errorf("Unexpected kind for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedKind, apiRequestInfo.Kind)
}
if successCase.expectedResource != apiRequestInfo.Resource {
t.Errorf("Unexpected resource for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedResource, apiRequestInfo.Resource)
}
if successCase.expectedSubresource != apiRequestInfo.Subresource {
t.Errorf("Unexpected resource for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedSubresource, apiRequestInfo.Subresource)
}
if successCase.expectedName != apiRequestInfo.Name {
t.Errorf("Unexpected name for url: %s, expected: %s, actual: %s", successCase.url, successCase.expectedName, apiRequestInfo.Name)
}
if !reflect.DeepEqual(successCase.expectedParts, apiRequestInfo.Parts) {
t.Errorf("Unexpected parts for url: %s, expected: %v, actual: %v", successCase.url, successCase.expectedParts, apiRequestInfo.Parts)
}
}
errorCases := map[string]string{
"no resource path": "/",
"just apiversion": "/api/version/",
"apiversion with no resource": "/api/version/",
}
for k, v := range errorCases {
req, err := http.NewRequest("GET", v, nil)
if err != nil {
t.Errorf("Unexpected error %v", err)
}
_, err = apiRequestInfoResolver.GetAPIRequestInfo(req)
if err == nil {
t.Errorf("Expected error for key: %s", k)
}
}
}
| apache-2.0 |
onedox/selenium | docs/api/java/org/openqa/selenium/logging/profiler/HttpProfilerLogEntry.html | 9050 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<title>HttpProfilerLogEntry</title>
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="HttpProfilerLogEntry";
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!-- -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/openqa/selenium/logging/profiler/EventType.html" title="enum in org.openqa.selenium.logging.profiler"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/openqa/selenium/logging/profiler/ProfilerLogEntry.html" title="class in org.openqa.selenium.logging.profiler"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/openqa/selenium/logging/profiler/HttpProfilerLogEntry.html" target="_top">Frames</a></li>
<li><a href="HttpProfilerLogEntry.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li>Field | </li>
<li><a href="#constructor_summary">Constr</a> | </li>
<li><a href="#methods_inherited_from_class_org.openqa.selenium.logging.LogEntry">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li>Field | </li>
<li><a href="#constructor_detail">Constr</a> | </li>
<li>Method</li>
</ul>
</div>
<a name="skip-navbar_top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.openqa.selenium.logging.profiler</div>
<h2 title="Class HttpProfilerLogEntry" class="title">Class HttpProfilerLogEntry</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li>java.lang.Object</li>
<li>
<ul class="inheritance">
<li><a href="../../../../../org/openqa/selenium/logging/LogEntry.html" title="class in org.openqa.selenium.logging">org.openqa.selenium.logging.LogEntry</a></li>
<li>
<ul class="inheritance">
<li><a href="../../../../../org/openqa/selenium/logging/profiler/ProfilerLogEntry.html" title="class in org.openqa.selenium.logging.profiler">org.openqa.selenium.logging.profiler.ProfilerLogEntry</a></li>
<li>
<ul class="inheritance">
<li>org.openqa.selenium.logging.profiler.HttpProfilerLogEntry</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="strong">HttpProfilerLogEntry</span>
extends <a href="../../../../../org/openqa/selenium/logging/profiler/ProfilerLogEntry.html" title="class in org.openqa.selenium.logging.profiler">ProfilerLogEntry</a></pre>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_summary">
<!-- -->
</a>
<h3>Constructor Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd"> </span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><strong><a href="../../../../../org/openqa/selenium/logging/profiler/HttpProfilerLogEntry.html#HttpProfilerLogEntry(java.lang.String, boolean)">HttpProfilerLogEntry</a></strong>(java.lang.String commandName,
boolean isStart)</code> </td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!-- -->
</a>
<h3>Method Summary</h3>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_org.openqa.selenium.logging.LogEntry">
<!-- -->
</a>
<h3>Methods inherited from class org.openqa.selenium.logging.<a href="../../../../../org/openqa/selenium/logging/LogEntry.html" title="class in org.openqa.selenium.logging">LogEntry</a></h3>
<code><a href="../../../../../org/openqa/selenium/logging/LogEntry.html#getLevel()">getLevel</a>, <a href="../../../../../org/openqa/selenium/logging/LogEntry.html#getMessage()">getMessage</a>, <a href="../../../../../org/openqa/selenium/logging/LogEntry.html#getTimestamp()">getTimestamp</a>, <a href="../../../../../org/openqa/selenium/logging/LogEntry.html#toMap()">toMap</a>, <a href="../../../../../org/openqa/selenium/logging/LogEntry.html#toString()">toString</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!-- -->
</a>
<h3>Methods inherited from class java.lang.Object</h3>
<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait</code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_detail">
<!-- -->
</a>
<h3>Constructor Detail</h3>
<a name="HttpProfilerLogEntry(java.lang.String, boolean)">
<!-- -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>HttpProfilerLogEntry</h4>
<pre>public HttpProfilerLogEntry(java.lang.String commandName,
boolean isStart)</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!-- -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/openqa/selenium/logging/profiler/EventType.html" title="enum in org.openqa.selenium.logging.profiler"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/openqa/selenium/logging/profiler/ProfilerLogEntry.html" title="class in org.openqa.selenium.logging.profiler"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/openqa/selenium/logging/profiler/HttpProfilerLogEntry.html" target="_top">Frames</a></li>
<li><a href="HttpProfilerLogEntry.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li>Field | </li>
<li><a href="#constructor_summary">Constr</a> | </li>
<li><a href="#methods_inherited_from_class_org.openqa.selenium.logging.LogEntry">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li>Field | </li>
<li><a href="#constructor_detail">Constr</a> | </li>
<li>Method</li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
| apache-2.0 |
weolar/miniblink49 | gen/v8_5_7/experimental-extras-libraries.cc | 2451 | // Copyright 2011 Google Inc. All Rights Reserved.
// This file was generated from .js source files by GYP. If you
// want to make changes to this file you should either change the
// javascript source files or the GYP script.
#include "src/v8.h"
#include "src/snapshot/natives.h"
#include "src/utils.h"
namespace v8 {
namespace internal {
static const char sources[] = { 10, 40, 102, 117, 110, 99, 116, 105, 111, 110, 32, 40, 103, 108, 111, 98, 97,
108, 44, 32, 98, 105, 110, 100, 105, 110, 103, 41, 32, 123, 10, 32, 32, 39, 117,
115, 101, 32, 115, 116, 114, 105, 99, 116, 39, 59, 10, 32, 32, 98, 105, 110,
100, 105, 110, 103, 46, 116, 101, 115, 116, 69, 120, 112, 101, 114, 105, 109,
101, 110, 116, 97, 108, 69, 120, 116, 114, 97, 83, 104, 111, 117, 108, 100, 82,
101, 116, 117, 114, 110, 84, 101, 110, 32, 61, 32, 102, 117, 110, 99, 116, 105,
111, 110, 32, 40, 41, 32, 123, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110,
32, 49, 48, 59, 10, 32, 32, 125, 59, 10, 32, 32, 98, 105, 110, 100, 105, 110,
103, 46, 116, 101, 115, 116, 69, 120, 112, 101, 114, 105, 109, 101, 110, 116,
97, 108, 69, 120, 116, 114, 97, 83, 104, 111, 117, 108, 100, 67, 97, 108, 108,
84, 111, 82, 117, 110, 116, 105, 109, 101, 32, 61, 32, 102, 117, 110, 99, 116,
105, 111, 110, 40, 41, 32, 123, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114,
110, 32, 98, 105, 110, 100, 105, 110, 103, 46, 114, 117, 110, 116, 105, 109,
101, 40, 51, 41, 59, 10, 32, 32, 125, 59, 10, 125, 41, 10 };
template <>
int NativesCollection<EXPERIMENTAL_EXTRAS>::GetBuiltinsCount() {
return 1;
}
template <>
int NativesCollection<EXPERIMENTAL_EXTRAS>::GetDebuggerCount() {
return 0;
}
template <>
int NativesCollection<EXPERIMENTAL_EXTRAS>::GetIndex(const char* name) {
if (strcmp(name, "test-experimental-extra") == 0) return 0;
return -1;
}
template <>
Vector<const char> NativesCollection<EXPERIMENTAL_EXTRAS>::GetScriptSource(int index) {
if (index == 0) return Vector<const char>(sources + 0, 235);
return Vector<const char>("", 0);
}
template <>
Vector<const char> NativesCollection<EXPERIMENTAL_EXTRAS>::GetScriptName(int index) {
if (index == 0) return Vector<const char>("native test-experimental-extra.js", 33);
return Vector<const char>("", 0);
}
template <>
Vector<const char> NativesCollection<EXPERIMENTAL_EXTRAS>::GetScriptsSource() {
return Vector<const char>(sources, 235);
}
} // internal
} // v8
| apache-2.0 |
yasharmaster/scancode-toolkit | tests/cluecode/data/ics/wpa_supplicant/wpa_supplicant.c | 1445 | /*
* WPA Supplicant
* Copyright (c) 2003-2008, Jouni Malinen <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
const char *wpa_supplicant_version =
"wpa_supplicant v" VERSION_STR "\n"
"Copyright (c) 2003-2008, Jouni Malinen <[email protected]> and contributors";
const char *wpa_supplicant_license =
"met:\n"
"\n";
const char *wpa_supplicant_full_license3 =
"1. Redistributions of source code must retain the above copyright\n"
" notice, this list of conditions and the following disclaimer.\n"
"\n"
"2. Redistributions in binary form must reproduce the above copyright\n"
" notice, this list of conditions and the following disclaimer in the\n"
" documentation and/or other materials provided with the distribution.\n"
"\n";
const char *wpa_supplicant_full_license4 =
"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
" names of its contributors may be used to endorse or promote products\n"
" derived from this software without specific prior written permission.\n"
"\n"
"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
const char *wpa_supplicant_full_license5 =
"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" | apache-2.0 |
siosio/intellij-community | plugins/IntentionPowerPak/test/com/siyeh/ipp/collections/to_mutable_collection/FieldAssignment_after.java | 151 | import java.util.*;
class Test {
private Set<String> foo;
void test(Test t1, String s) {
t1.foo = new HashSet<>();
t1.foo.add(s);
}
} | apache-2.0 |
domchen/typescript-plus | tests/cases/fourslash/signatureHelpFunctionOverload.ts | 652 | /// <reference path='fourslash.ts' />
////function functionOverload();
////function functionOverload(test: string);
////function functionOverload(test?: string) { }
////functionOverload(/*functionOverload1*/);
////functionOverload(""/*functionOverload2*/);
verify.signatureHelp(
{
marker: "functionOverload1",
overloadsCount: 2,
text: "functionOverload(): any",
parameterCount: 0,
},
{
marker: "functionOverload2",
overloadsCount: 2,
text: "functionOverload(test: string): any",
parameterName: "test",
parameterSpan: "test: string",
},
);
| apache-2.0 |
spockframework/spock | spock-core/src/main/java/org/spockframework/runtime/condition/IObjectRendererService.java | 809 | /*
* Copyright 2010 the original author or authors.
*
* 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 org.spockframework.runtime.condition;
public interface IObjectRendererService extends IObjectRenderer<Object> {
<T> void addRenderer(Class<T> type, IObjectRenderer<? super T> renderer);
}
| apache-2.0 |
elijah513/druid | server/src/test/java/io/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java | 11028 | /*
* Licensed to Metamarkets Group Inc. (Metamarkets) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. Metamarkets licenses this file
* to you 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 io.druid.metadata;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import io.druid.jackson.DefaultObjectMapper;
import io.druid.timeline.DataSegment;
import io.druid.timeline.partition.LinearShardSpec;
import org.joda.time.Interval;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.skife.jdbi.v2.Handle;
import org.skife.jdbi.v2.tweak.HandleCallback;
import java.io.IOException;
import java.util.Set;
public class IndexerSQLMetadataStorageCoordinatorTest
{
private final MetadataStorageTablesConfig tablesConfig = MetadataStorageTablesConfig.fromBase("test");
private final TestDerbyConnector derbyConnector = new TestDerbyConnector(
Suppliers.ofInstance(new MetadataStorageConnectorConfig()),
Suppliers.ofInstance(tablesConfig)
);
private final ObjectMapper mapper = new DefaultObjectMapper();
private final DataSegment defaultSegment = new DataSegment(
"dataSource",
Interval.parse("2015-01-01T00Z/2015-01-02T00Z"),
"version",
ImmutableMap.<String, Object>of(),
ImmutableList.of("dim1"),
ImmutableList.of("m1"),
new LinearShardSpec(0),
9,
100
);
private final DataSegment defaultSegment2 = new DataSegment(
"dataSource",
Interval.parse("2015-01-01T00Z/2015-01-02T00Z"),
"version",
ImmutableMap.<String, Object>of(),
ImmutableList.of("dim1"),
ImmutableList.of("m1"),
new LinearShardSpec(1),
9,
100
);
private final Set<DataSegment> segments = ImmutableSet.of(defaultSegment, defaultSegment2);
IndexerSQLMetadataStorageCoordinator coordinator;
@Before
public void setUp()
{
mapper.registerSubtypes(LinearShardSpec.class);
derbyConnector.createTaskTables();
derbyConnector.createSegmentTable();
coordinator = new IndexerSQLMetadataStorageCoordinator(
mapper,
tablesConfig,
derbyConnector
);
}
@After
public void tearDown()
{
derbyConnector.tearDown();
}
private void unUseSegment()
{
for (final DataSegment segment : segments) {
Assert.assertEquals(
1, (int) derbyConnector.getDBI().<Integer>withHandle(
new HandleCallback<Integer>()
{
@Override
public Integer withHandle(Handle handle) throws Exception
{
return handle.createStatement(
String.format("UPDATE %s SET used = false WHERE id = :id", tablesConfig.getSegmentsTable())
)
.bind("id", segment.getIdentifier())
.execute();
}
}
)
);
}
}
@Test
public void testSimpleAnnounce() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertArrayEquals(
mapper.writeValueAsString(defaultSegment).getBytes("UTF-8"),
derbyConnector.lookup(
tablesConfig.getSegmentsTable(),
"id",
"payload",
defaultSegment.getIdentifier()
)
);
}
@Test
public void testSimpleUsedList() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval()
)
)
);
}
@Test
public void testSimpleUnUsedList() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval()
)
)
);
}
@Test
public void testUsedOverlapLow() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Set<DataSegment> actualSegments = ImmutableSet.copyOf(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
Interval.parse("2014-12-31T23:59:59.999Z/2015-01-01T00:00:00.001Z") // end is exclusive
)
);
Assert.assertEquals(
segments,
actualSegments
);
}
@Test
public void testUsedOverlapHigh() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
Interval.parse("2015-1-1T23:59:59.999Z/2015-02-01T00Z")
)
)
);
}
@Test
public void testUsedOutOfBoundsLow() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertTrue(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
new Interval(defaultSegment.getInterval().getStart().minus(1), defaultSegment.getInterval().getStart())
).isEmpty()
);
}
@Test
public void testUsedOutOfBoundsHigh() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertTrue(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
new Interval(defaultSegment.getInterval().getEnd(), defaultSegment.getInterval().getEnd().plusDays(10))
).isEmpty()
);
}
@Test
public void testUsedWithinBoundsEnd() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withEnd(defaultSegment.getInterval().getEnd().minusMillis(1))
)
)
);
}
@Test
public void testUsedOverlapEnd() throws IOException
{
coordinator.announceHistoricalSegments(segments);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUsedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withEnd(defaultSegment.getInterval().getEnd().plusMillis(1))
)
)
);
}
@Test
public void testUnUsedOverlapLow() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertTrue(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
new Interval(
defaultSegment.getInterval().getStart().minus(1),
defaultSegment.getInterval().getStart().plus(1)
)
).isEmpty()
);
}
@Test
public void testUnUsedUnderlapLow() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertTrue(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
new Interval(defaultSegment.getInterval().getStart().plus(1), defaultSegment.getInterval().getEnd())
).isEmpty()
);
}
@Test
public void testUnUsedUnderlapHigh() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertTrue(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
new Interval(defaultSegment.getInterval().getStart(), defaultSegment.getInterval().getEnd().minus(1))
).isEmpty()
);
}
@Test
public void testUnUsedOverlapHigh() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertTrue(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withStart(defaultSegment.getInterval().getEnd().minus(1))
).isEmpty()
);
}
@Test
public void testUnUsedBigOverlap() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
Interval.parse("2000/2999")
)
)
);
}
@Test
public void testUnUsedLowRange() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withStart(defaultSegment.getInterval().getStart().minus(1))
)
)
);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withStart(defaultSegment.getInterval().getStart().minusYears(1))
)
)
);
}
@Test
public void testUnUsedHighRange() throws IOException
{
coordinator.announceHistoricalSegments(segments);
unUseSegment();
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withEnd(defaultSegment.getInterval().getEnd().plus(1))
)
)
);
Assert.assertEquals(
segments,
ImmutableSet.copyOf(
coordinator.getUnusedSegmentsForInterval(
defaultSegment.getDataSource(),
defaultSegment.getInterval().withEnd(defaultSegment.getInterval().getEnd().plusYears(1))
)
)
);
}
}
| apache-2.0 |
bravo-zhang/spark | external/kafka-0-10/src/test/scala/org/apache/spark/streaming/kafka010/KafkaRDDSuite.scala | 9481 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.spark.streaming.kafka010
import java.{ util => ju }
import java.io.File
import scala.collection.JavaConverters._
import scala.util.Random
import kafka.common.TopicAndPartition
import kafka.log._
import kafka.message._
import kafka.utils.Pool
import org.apache.kafka.common.TopicPartition
import org.apache.kafka.common.serialization.StringDeserializer
import org.scalatest.BeforeAndAfterAll
import org.apache.spark._
import org.apache.spark.scheduler.ExecutorCacheTaskLocation
import org.apache.spark.streaming.kafka010.mocks.MockTime
class KafkaRDDSuite extends SparkFunSuite with BeforeAndAfterAll {
private var kafkaTestUtils: KafkaTestUtils = _
private val sparkConf = new SparkConf().setMaster("local[4]")
.setAppName(this.getClass.getSimpleName)
private var sc: SparkContext = _
override def beforeAll {
sc = new SparkContext(sparkConf)
kafkaTestUtils = new KafkaTestUtils
kafkaTestUtils.setup()
}
override def afterAll {
if (sc != null) {
sc.stop
sc = null
}
if (kafkaTestUtils != null) {
kafkaTestUtils.teardown()
kafkaTestUtils = null
}
}
private def getKafkaParams() = Map[String, Object](
"bootstrap.servers" -> kafkaTestUtils.brokerAddress,
"key.deserializer" -> classOf[StringDeserializer],
"value.deserializer" -> classOf[StringDeserializer],
"group.id" -> s"test-consumer-${Random.nextInt}-${System.currentTimeMillis}"
).asJava
private val preferredHosts = LocationStrategies.PreferConsistent
private def compactLogs(topic: String, partition: Int, messages: Array[(String, String)]) {
val mockTime = new MockTime()
// LogCleaner in 0.10 version of Kafka is still expecting the old TopicAndPartition api
val logs = new Pool[TopicAndPartition, Log]()
val logDir = kafkaTestUtils.brokerLogDir
val dir = new File(logDir, topic + "-" + partition)
dir.mkdirs()
val logProps = new ju.Properties()
logProps.put(LogConfig.CleanupPolicyProp, LogConfig.Compact)
logProps.put(LogConfig.MinCleanableDirtyRatioProp, java.lang.Float.valueOf(0.1f))
val log = new Log(
dir,
LogConfig(logProps),
0L,
mockTime.scheduler,
mockTime
)
messages.foreach { case (k, v) =>
val msg = new ByteBufferMessageSet(
NoCompressionCodec,
new Message(v.getBytes, k.getBytes, Message.NoTimestamp, Message.CurrentMagicValue))
log.append(msg)
}
log.roll()
logs.put(TopicAndPartition(topic, partition), log)
val cleaner = new LogCleaner(CleanerConfig(), logDirs = Array(dir), logs = logs)
cleaner.startup()
cleaner.awaitCleaned(topic, partition, log.activeSegment.baseOffset, 1000)
cleaner.shutdown()
mockTime.scheduler.shutdown()
}
test("basic usage") {
val topic = s"topicbasic-${Random.nextInt}-${System.currentTimeMillis}"
kafkaTestUtils.createTopic(topic)
val messages = Array("the", "quick", "brown", "fox")
kafkaTestUtils.sendMessages(topic, messages)
val kafkaParams = getKafkaParams()
val offsetRanges = Array(OffsetRange(topic, 0, 0, messages.size))
val rdd = KafkaUtils.createRDD[String, String](sc, kafkaParams, offsetRanges, preferredHosts)
.map(_.value)
val received = rdd.collect.toSet
assert(received === messages.toSet)
// size-related method optimizations return sane results
assert(rdd.count === messages.size)
assert(rdd.countApprox(0).getFinalValue.mean === messages.size)
assert(!rdd.isEmpty)
assert(rdd.take(1).size === 1)
assert(rdd.take(1).head === messages.head)
assert(rdd.take(messages.size + 10).size === messages.size)
val emptyRdd = KafkaUtils.createRDD[String, String](
sc, kafkaParams, Array(OffsetRange(topic, 0, 0, 0)), preferredHosts)
assert(emptyRdd.isEmpty)
// invalid offset ranges throw exceptions
val badRanges = Array(OffsetRange(topic, 0, 0, messages.size + 1))
intercept[SparkException] {
val result = KafkaUtils.createRDD[String, String](sc, kafkaParams, badRanges, preferredHosts)
.map(_.value)
.collect()
}
}
test("compacted topic") {
val compactConf = sparkConf.clone()
compactConf.set("spark.streaming.kafka.allowNonConsecutiveOffsets", "true")
sc.stop()
sc = new SparkContext(compactConf)
val topic = s"topiccompacted-${Random.nextInt}-${System.currentTimeMillis}"
val messages = Array(
("a", "1"),
("a", "2"),
("b", "1"),
("c", "1"),
("c", "2"),
("b", "2"),
("b", "3")
)
val compactedMessages = Array(
("a", "2"),
("b", "3"),
("c", "2")
)
compactLogs(topic, 0, messages)
val props = new ju.Properties()
props.put("cleanup.policy", "compact")
props.put("flush.messages", "1")
props.put("segment.ms", "1")
props.put("segment.bytes", "256")
kafkaTestUtils.createTopic(topic, 1, props)
val kafkaParams = getKafkaParams()
val offsetRanges = Array(OffsetRange(topic, 0, 0, messages.size))
val rdd = KafkaUtils.createRDD[String, String](
sc, kafkaParams, offsetRanges, preferredHosts
).map(m => m.key -> m.value)
val received = rdd.collect.toSet
assert(received === compactedMessages.toSet)
// size-related method optimizations return sane results
assert(rdd.count === compactedMessages.size)
assert(rdd.countApprox(0).getFinalValue.mean === compactedMessages.size)
assert(!rdd.isEmpty)
assert(rdd.take(1).size === 1)
assert(rdd.take(1).head === compactedMessages.head)
assert(rdd.take(messages.size + 10).size === compactedMessages.size)
val emptyRdd = KafkaUtils.createRDD[String, String](
sc, kafkaParams, Array(OffsetRange(topic, 0, 0, 0)), preferredHosts)
assert(emptyRdd.isEmpty)
// invalid offset ranges throw exceptions
val badRanges = Array(OffsetRange(topic, 0, 0, messages.size + 1))
intercept[SparkException] {
val result = KafkaUtils.createRDD[String, String](sc, kafkaParams, badRanges, preferredHosts)
.map(_.value)
.collect()
}
}
test("iterator boundary conditions") {
// the idea is to find e.g. off-by-one errors between what kafka has available and the rdd
val topic = s"topicboundary-${Random.nextInt}-${System.currentTimeMillis}"
val sent = Map("a" -> 5, "b" -> 3, "c" -> 10)
kafkaTestUtils.createTopic(topic)
val kafkaParams = getKafkaParams()
// this is the "lots of messages" case
kafkaTestUtils.sendMessages(topic, sent)
var sentCount = sent.values.sum
val rdd = KafkaUtils.createRDD[String, String](sc, kafkaParams,
Array(OffsetRange(topic, 0, 0, sentCount)), preferredHosts)
val ranges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
val rangeCount = ranges.map(o => o.untilOffset - o.fromOffset).sum
assert(rangeCount === sentCount, "offset range didn't include all sent messages")
assert(rdd.map(_.offset).collect.sorted === (0 until sentCount).toArray,
"didn't get all sent messages")
// this is the "0 messages" case
val rdd2 = KafkaUtils.createRDD[String, String](sc, kafkaParams,
Array(OffsetRange(topic, 0, sentCount, sentCount)), preferredHosts)
// shouldn't get anything, since message is sent after rdd was defined
val sentOnlyOne = Map("d" -> 1)
kafkaTestUtils.sendMessages(topic, sentOnlyOne)
assert(rdd2.map(_.value).collect.size === 0, "got messages when there shouldn't be any")
// this is the "exactly 1 message" case, namely the single message from sentOnlyOne above
val rdd3 = KafkaUtils.createRDD[String, String](sc, kafkaParams,
Array(OffsetRange(topic, 0, sentCount, sentCount + 1)), preferredHosts)
// send lots of messages after rdd was defined, they shouldn't show up
kafkaTestUtils.sendMessages(topic, Map("extra" -> 22))
assert(rdd3.map(_.value).collect.head === sentOnlyOne.keys.head,
"didn't get exactly one message")
}
test("executor sorting") {
val kafkaParams = new ju.HashMap[String, Object](getKafkaParams())
kafkaParams.put("auto.offset.reset", "none")
val rdd = new KafkaRDD[String, String](
sc,
kafkaParams,
Array(OffsetRange("unused", 0, 1, 2)),
ju.Collections.emptyMap[TopicPartition, String](),
true)
val a3 = ExecutorCacheTaskLocation("a", "3")
val a4 = ExecutorCacheTaskLocation("a", "4")
val b1 = ExecutorCacheTaskLocation("b", "1")
val b2 = ExecutorCacheTaskLocation("b", "2")
val correct = Array(b2, b1, a4, a3)
correct.permutations.foreach { p =>
assert(p.sortWith(rdd.compareExecutors) === correct)
}
}
}
| apache-2.0 |
siosio/intellij-community | platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/LibraryGroupNode.java | 5590 | // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.projectView.impl.nodes;
import com.intellij.ide.IdeBundle;
import com.intellij.ide.projectView.PresentationData;
import com.intellij.ide.projectView.ProjectViewNode;
import com.intellij.ide.projectView.ViewSettings;
import com.intellij.ide.util.treeView.AbstractTreeNode;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.roots.*;
import com.intellij.openapi.roots.impl.libraries.LibraryEx;
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.roots.libraries.LibraryType;
import com.intellij.openapi.roots.libraries.PersistentLibraryKind;
import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.intellij.util.PlatformIcons;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class LibraryGroupNode extends ProjectViewNode<LibraryGroupElement> {
public LibraryGroupNode(Project project, @NotNull LibraryGroupElement value, ViewSettings viewSettings) {
super(project, value, viewSettings);
}
@Override
@NotNull
public Collection<AbstractTreeNode<?>> getChildren() {
Module module = getValue().getModule();
ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
List<AbstractTreeNode<?>> children = new ArrayList<>();
OrderEntry[] orderEntries = moduleRootManager.getOrderEntries();
for (final OrderEntry orderEntry : orderEntries) {
if (orderEntry instanceof LibraryOrderEntry) {
final LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry)orderEntry;
final Library library = libraryOrderEntry.getLibrary();
if (library == null) {
continue;
}
final String libraryName = library.getName();
if (libraryName == null || libraryName.length() == 0) {
addLibraryChildren(libraryOrderEntry, children, getProject(), this);
}
else {
children.add(new NamedLibraryElementNode(getProject(), new NamedLibraryElement(module, libraryOrderEntry), getSettings()));
}
}
else if (orderEntry instanceof JdkOrderEntry) {
final JdkOrderEntry jdkOrderEntry = (JdkOrderEntry)orderEntry;
final Sdk jdk = jdkOrderEntry.getJdk();
if (jdk != null) {
children.add(new NamedLibraryElementNode(getProject(), new NamedLibraryElement(module, jdkOrderEntry), getSettings()));
}
}
}
return children;
}
public static void addLibraryChildren(LibraryOrSdkOrderEntry entry, List<? super AbstractTreeNode<?>> children, Project project, ProjectViewNode node) {
final PsiManager psiManager = PsiManager.getInstance(project);
VirtualFile[] files =
entry instanceof LibraryOrderEntry ? getLibraryRoots((LibraryOrderEntry)entry) : entry.getRootFiles(OrderRootType.CLASSES);
for (final VirtualFile file : files) {
if (!file.isValid()) continue;
if (file.isDirectory()) {
final PsiDirectory psiDir = psiManager.findDirectory(file);
if (psiDir == null) {
continue;
}
children.add(new PsiDirectoryNode(project, psiDir, node.getSettings()));
}
else {
final PsiFile psiFile = psiManager.findFile(file);
if (psiFile == null) continue;
children.add(new PsiFileNode(project, psiFile, node.getSettings()));
}
}
}
@Override
public String getTestPresentation() {
return "Libraries";
}
@Override
public boolean contains(@NotNull VirtualFile file) {
final ProjectFileIndex index = ProjectRootManager.getInstance(getProject()).getFileIndex();
if (!index.isInLibrary(file)) {
return false;
}
return someChildContainsFile(file, false);
}
@Override
public void update(@NotNull PresentationData presentation) {
presentation.setPresentableText(IdeBundle.message("node.projectview.libraries"));
presentation.setIcon(PlatformIcons.LIBRARY_ICON);
}
@Override
public boolean canNavigate() {
return ProjectSettingsService.getInstance(myProject).canOpenModuleLibrarySettings();
}
@Override
public void navigate(final boolean requestFocus) {
Module module = getValue().getModule();
ProjectSettingsService.getInstance(myProject).openModuleLibrarySettings(module);
}
public static VirtualFile @NotNull [] getLibraryRoots(@NotNull LibraryOrderEntry orderEntry) {
Library library = orderEntry.getLibrary();
if (library == null) return VirtualFile.EMPTY_ARRAY;
OrderRootType[] rootTypes = LibraryType.DEFAULT_EXTERNAL_ROOT_TYPES;
if (library instanceof LibraryEx) {
if (((LibraryEx)library).isDisposed()) return VirtualFile.EMPTY_ARRAY;
PersistentLibraryKind<?> libKind = ((LibraryEx)library).getKind();
if (libKind != null) {
rootTypes = LibraryType.findByKind(libKind).getExternalRootTypes();
}
}
final ArrayList<VirtualFile> files = new ArrayList<>();
for (OrderRootType rootType : rootTypes) {
files.addAll(Arrays.asList(library.getFiles(rootType)));
}
return VfsUtilCore.toVirtualFileArray(files);
}
}
| apache-2.0 |
BigBoss424/portfolio | v8/development/node_modules/gatsby/node_modules/eslint/lib/rules/template-curly-spacing.js | 4149 | /**
* @fileoverview Rule to enforce spacing around embedded expressions of template strings
* @author Toru Nagashima
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
const OPEN_PAREN = /\$\{$/u;
const CLOSE_PAREN = /^\}/u;
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = {
meta: {
type: "layout",
docs: {
description: "require or disallow spacing around embedded expressions of template strings",
category: "ECMAScript 6",
recommended: false,
url: "https://eslint.org/docs/rules/template-curly-spacing"
},
fixable: "whitespace",
schema: [
{ enum: ["always", "never"] }
],
messages: {
expectedBefore: "Expected space(s) before '}'.",
expectedAfter: "Expected space(s) after '${'.",
unexpectedBefore: "Unexpected space(s) before '}'.",
unexpectedAfter: "Unexpected space(s) after '${'."
}
},
create(context) {
const sourceCode = context.getSourceCode();
const always = context.options[0] === "always";
const prefix = always ? "expected" : "unexpected";
/**
* Checks spacing before `}` of a given token.
* @param {Token} token A token to check. This is a Template token.
* @returns {void}
*/
function checkSpacingBefore(token) {
const prevToken = sourceCode.getTokenBefore(token);
if (prevToken &&
CLOSE_PAREN.test(token.value) &&
astUtils.isTokenOnSameLine(prevToken, token) &&
sourceCode.isSpaceBetweenTokens(prevToken, token) !== always
) {
context.report({
loc: token.loc.start,
messageId: `${prefix}Before`,
fix(fixer) {
if (always) {
return fixer.insertTextBefore(token, " ");
}
return fixer.removeRange([
prevToken.range[1],
token.range[0]
]);
}
});
}
}
/**
* Checks spacing after `${` of a given token.
* @param {Token} token A token to check. This is a Template token.
* @returns {void}
*/
function checkSpacingAfter(token) {
const nextToken = sourceCode.getTokenAfter(token);
if (nextToken &&
OPEN_PAREN.test(token.value) &&
astUtils.isTokenOnSameLine(token, nextToken) &&
sourceCode.isSpaceBetweenTokens(token, nextToken) !== always
) {
context.report({
loc: {
line: token.loc.end.line,
column: token.loc.end.column - 2
},
messageId: `${prefix}After`,
fix(fixer) {
if (always) {
return fixer.insertTextAfter(token, " ");
}
return fixer.removeRange([
token.range[1],
nextToken.range[0]
]);
}
});
}
}
return {
TemplateElement(node) {
const token = sourceCode.getFirstToken(node);
checkSpacingBefore(token);
checkSpacingAfter(token);
}
};
}
};
| apache-2.0 |
mlperf/inference_results_v0.7 | open/Inspur/code/rnnt/tensorrt/preprocessing/parts/text/symbols.py | 749 | # Copyright (c) 2017 Keith Ito
""" from https://github.com/keithito/tacotron """
'''
Defines the set of symbols used in text input to the model.
The default is a set of ASCII characters that works well for English or text that has been run through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details. '''
from . import cmudict
_pad = '_'
_punctuation = '!\'(),.:;? '
_special = '-'
_letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
# Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters):
_arpabet = ['@' + s for s in cmudict.valid_symbols]
# Export all symbols:
symbols = [_pad] + list(_special) + list(_punctuation) + list(_letters) + _arpabet
| apache-2.0 |
yasharmaster/scancode-toolkit | tests/cluecode/data/ics/bison-src/nullable.h | 156 | /* Part of the bison parser generator,
Copyright (C) 2000, 2002 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler. | apache-2.0 |
nikhilvibhav/camel | components/camel-jms/src/test/java/org/apache/camel/component/jms/JmsAllowNullBodyTest.java | 3981 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.camel.component.jms;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import org.apache.camel.CamelContext;
import org.apache.camel.CamelExecutionException;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.test.junit5.CamelTestSupport;
import org.junit.jupiter.api.Test;
import static org.apache.camel.component.jms.JmsComponent.jmsComponentAutoAcknowledge;
import static org.apache.camel.test.junit5.TestSupport.assertIsInstanceOf;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
/**
*
*/
public class JmsAllowNullBodyTest extends CamelTestSupport {
@Test
public void testAllowNullBodyDefault() throws Exception {
getMockEndpoint("mock:result").expectedMessageCount(1);
getMockEndpoint("mock:result").message(0).body().isNull();
getMockEndpoint("mock:result").message(0).header("bar").isEqualTo(123);
// allow null body is default enabled
template.sendBodyAndHeader("activemq:queue:foo", null, "bar", 123);
assertMockEndpointsSatisfied();
}
@Test
public void testAllowNullBody() throws Exception {
getMockEndpoint("mock:result").expectedMessageCount(1);
getMockEndpoint("mock:result").message(0).body().isNull();
getMockEndpoint("mock:result").message(0).header("bar").isEqualTo(123);
template.sendBodyAndHeader("activemq:queue:foo?allowNullBody=true", null, "bar", 123);
assertMockEndpointsSatisfied();
}
@Test
public void testAllowNullTextBody() throws Exception {
getMockEndpoint("mock:result").expectedMessageCount(1);
getMockEndpoint("mock:result").message(0).body().isNull();
getMockEndpoint("mock:result").message(0).header("bar").isEqualTo(123);
template.sendBodyAndHeader("activemq:queue:foo?allowNullBody=true&jmsMessageType=Text", null, "bar", 123);
assertMockEndpointsSatisfied();
}
@Test
public void testNoAllowNullBody() throws Exception {
try {
template.sendBodyAndHeader("activemq:queue:foo?allowNullBody=false", null, "bar", 123);
fail("Should have thrown exception");
} catch (CamelExecutionException e) {
JMSException cause = assertIsInstanceOf(JMSException.class, e.getCause().getCause());
assertEquals("Cannot send message as message body is null, and option allowNullBody is false.", cause.getMessage());
}
}
@Override
protected CamelContext createCamelContext() throws Exception {
CamelContext camelContext = super.createCamelContext();
ConnectionFactory connectionFactory = CamelJmsTestHelper.createConnectionFactory();
camelContext.addComponent("activemq", jmsComponentAutoAcknowledge(connectionFactory));
return camelContext;
}
@Override
protected RouteBuilder createRouteBuilder() throws Exception {
return new RouteBuilder() {
@Override
public void configure() throws Exception {
from("activemq:queue:foo").to("mock:result");
}
};
}
}
| apache-2.0 |
j16r/rust | src/test/run-pass/issue-1821.rs | 565 | // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Issue #1821 - Don't recurse trying to typecheck this
enum t {
foo(~[t])
}
pub fn main() {}
| apache-2.0 |
hsbhathiya/stratos | components/org.apache.stratos.manager.console/modules/console/scripts/server.js | 1188 | /*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*
*/
var server = {};
(function (server) {
var USER = 'server.user';
var log = new Log();
/**
* Returns the currently logged in user
*/
server.current = function (session, user) {
if (arguments.length > 1) {
session.put(USER, user);
return user;
}
return session.get(USER);
};
}(server));
| apache-2.0 |
wcwxyz/docker | graph/service.go | 2129 | package graph
import (
"fmt"
"io"
"runtime"
"time"
"github.com/Sirupsen/logrus"
"github.com/docker/docker/api/types"
"github.com/docker/docker/utils"
)
// Lookup looks up an image by name in a TagStore and returns it as an
// ImageInspect structure.
func (s *TagStore) Lookup(name string) (*types.ImageInspect, error) {
image, err := s.LookupImage(name)
if err != nil || image == nil {
return nil, fmt.Errorf("No such image: %s", name)
}
var tags = make([]string, 0)
s.Lock()
for repoName, repository := range s.Repositories {
for ref, id := range repository {
if id == image.ID {
imgRef := utils.ImageReference(repoName, ref)
tags = append(tags, imgRef)
}
}
}
s.Unlock()
imageInspect := &types.ImageInspect{
ID: image.ID,
Tags: tags,
Parent: image.Parent,
Comment: image.Comment,
Created: image.Created.Format(time.RFC3339Nano),
Container: image.Container,
ContainerConfig: &image.ContainerConfig,
DockerVersion: image.DockerVersion,
Author: image.Author,
Config: image.Config,
Architecture: image.Architecture,
Os: image.OS,
Size: image.Size,
VirtualSize: s.graph.GetParentsSize(image) + image.Size,
}
imageInspect.GraphDriver.Name = s.graph.driver.String()
graphDriverData, err := s.graph.driver.GetMetadata(image.ID)
if err != nil {
return nil, err
}
imageInspect.GraphDriver.Data = graphDriverData
return imageInspect, nil
}
// ImageTarLayer return the tarLayer of the image
func (s *TagStore) ImageTarLayer(name string, dest io.Writer) error {
if image, err := s.LookupImage(name); err == nil && image != nil {
// On Windows, the base layer cannot be exported
if runtime.GOOS != "windows" || image.Parent != "" {
fs, err := s.graph.TarLayer(image)
if err != nil {
return err
}
defer fs.Close()
written, err := io.Copy(dest, fs)
if err != nil {
return err
}
logrus.Debugf("rendered layer for %s of [%d] size", image.ID, written)
}
return nil
}
return fmt.Errorf("No such image: %s", name)
}
| apache-2.0 |
dugilos/nar-maven-plugin | src/test/java/com/github/maven_nar/cpptasks/compiler/TestAbstractCompiler.java | 3408 | /*
* #%L
* Native ARchive plugin for Maven
* %%
* Copyright (C) 2002 - 2014 NAR Maven Plugin developers.
* %%
* 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.
* #L%
*/
package com.github.maven_nar.cpptasks.compiler;
import java.io.File;
import org.apache.tools.ant.BuildException;
import com.github.maven_nar.cpptasks.CCTask;
import com.github.maven_nar.cpptasks.CompilerDef;
import com.github.maven_nar.cpptasks.ProcessorDef;
import com.github.maven_nar.cpptasks.VersionInfo;
import com.github.maven_nar.cpptasks.parser.CParser;
import com.github.maven_nar.cpptasks.parser.Parser;
/**
* Test for abstract compiler class
*
* Override create to test concrete compiler implementions
*/
public class TestAbstractCompiler extends TestAbstractProcessor {
private class DummyAbstractCompiler extends AbstractCompiler {
public DummyAbstractCompiler() {
super(new String[] {
".cpp", ".c"
}, new String[] {
".hpp", ".h", ".inl"
}, ".o");
}
public void compile(final CCTask task, final File[] srcfile, final File[] outputfile,
final CompilerConfiguration config) throws BuildException {
throw new BuildException("Not implemented");
}
@Override
public CompilerConfiguration createConfiguration(final CCTask task, final LinkType linkType,
final ProcessorDef[] def1, final CompilerDef def2,
final com.github.maven_nar.cpptasks.TargetDef targetPlatform, final VersionInfo versionInfo) {
return null;
}
@Override
public Parser createParser(final File file) {
return new CParser();
}
@Override
public String getIdentifier() {
return "dummy";
}
@Override
public Linker getLinker(final LinkType type) {
return null;
}
}
public TestAbstractCompiler(final String name) {
super(name);
}
@Override
protected AbstractProcessor create() {
return new DummyAbstractCompiler();
}
public void failingtestGetOutputFileName1() {
final AbstractProcessor compiler = create();
String[] output = compiler.getOutputFileNames("c:/foo\\bar\\hello.c", null);
assertEquals("hello" + getObjectExtension(), output[0]);
output = compiler.getOutputFileNames("c:/foo\\bar/hello.c", null);
assertEquals("hello" + getObjectExtension(), output[0]);
output = compiler.getOutputFileNames("hello.c", null);
assertEquals("hello" + getObjectExtension(), output[0]);
output = compiler.getOutputFileNames("c:/foo\\bar\\hello.h", null);
assertEquals(0, output.length);
output = compiler.getOutputFileNames("c:/foo\\bar/hello.h", null);
assertEquals(0, output.length);
}
protected String getObjectExtension() {
return ".o";
}
public void testCanParseTlb() {
final AbstractCompiler compiler = (AbstractCompiler) create();
assertEquals(false, compiler.canParse(new File("sample.tlb")));
}
}
| apache-2.0 |
plantain-00/TypeScript | tests/cases/fourslash/goToTypeDefinitionAliases.ts | 645 | /// <reference path='fourslash.ts' />
// @Filename: goToTypeDefinitioAliases_module1.ts
/////*definition*/interface I {
//// p;
////}
////export {I as I2};
// @Filename: goToTypeDefinitioAliases_module2.ts
////import {I2 as I3} from "./goToTypeDefinitioAliases_module1";
////var v1: I3;
////export {v1 as v2};
// @Filename: goToTypeDefinitioAliases_module3.ts
////import {/*reference1*/v2 as v3} from "./goToTypeDefinitioAliases_module2";
/////*reference2*/v3;
goTo.marker('reference1');
goTo.type();
verify.caretAtMarker('definition');
goTo.marker('reference2');
goTo.type();
verify.caretAtMarker('definition');
| apache-2.0 |
tdiesler/camel | components/camel-spring-redis/src/test/java/org/apache/camel/component/redis/RedisTestSupport.java | 2242 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.camel.component.redis;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.Processor;
import org.apache.camel.Produce;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.test.junit5.CamelTestSupport;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoSettings;
import org.springframework.data.redis.core.RedisTemplate;
@MockitoSettings
public class RedisTestSupport extends CamelTestSupport {
@Mock
protected RedisTemplate<String, String> redisTemplate;
@Produce("direct:start")
protected ProducerTemplate template;
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
public void configure() {
from("direct:start")
.to("spring-redis://localhost:6379?redisTemplate=#redisTemplate");
}
};
}
protected Object sendHeaders(final Object... headers) {
Exchange exchange = template.send(new Processor() {
public void process(Exchange exchange) throws Exception {
Message in = exchange.getIn();
for (int i = 0; i < headers.length; i = i + 2) {
in.setHeader(headers[i].toString(), headers[i + 1]);
}
}
});
return exchange.getIn().getBody();
}
}
| apache-2.0 |
ssaroha/node-webrtc | third_party/webrtc/include/chromium/src/third_party/mesa/src/src/gallium/auxiliary/draw/draw_so_emit_tmp.h | 1752 | #define FUNC_VARS \
struct pt_so_emit *so, \
const struct draw_prim_info *input_prims, \
const struct draw_vertex_info *input_verts, \
unsigned start, \
unsigned count
#define FUNC_ENTER \
/* declare more local vars */ \
const unsigned prim = input_prims->prim; \
const unsigned prim_flags = input_prims->flags; \
const boolean quads_flatshade_last = FALSE; \
const boolean last_vertex_last = TRUE; \
do { \
debug_assert(input_prims->primitive_count == 1); \
switch (prim) { \
case PIPE_PRIM_LINES_ADJACENCY: \
case PIPE_PRIM_LINE_STRIP_ADJACENCY: \
case PIPE_PRIM_TRIANGLES_ADJACENCY: \
case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY: \
debug_assert(!"unexpected primitive type in stream output"); \
return; \
default: \
break; \
} \
} while (0) \
#define POINT(i0) so_point(so,i0)
#define LINE(flags,i0,i1) so_line(so,i0,i1)
#define TRIANGLE(flags,i0,i1,i2) so_tri(so,i0,i1,i2)
#include "draw_decompose_tmp.h"
| bsd-2-clause |
santoshn/softboundcets-34 | softboundcets-llvm-clang34/include/llvm/CodeGen/RegisterPressure.h | 17065 | //===-- RegisterPressure.h - Dynamic Register Pressure -*- C++ -*-------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the RegisterPressure class which can be used to track
// MachineInstr level register pressure.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_REGISTERPRESSURE_H
#define LLVM_CODEGEN_REGISTERPRESSURE_H
#include "llvm/ADT/SparseSet.h"
#include "llvm/CodeGen/SlotIndexes.h"
#include "llvm/Target/TargetRegisterInfo.h"
namespace llvm {
class LiveIntervals;
class LiveRange;
class RegisterClassInfo;
class MachineInstr;
/// Base class for register pressure results.
struct RegisterPressure {
/// Map of max reg pressure indexed by pressure set ID, not class ID.
std::vector<unsigned> MaxSetPressure;
/// List of live in virtual registers or physical register units.
SmallVector<unsigned,8> LiveInRegs;
SmallVector<unsigned,8> LiveOutRegs;
/// Increase register pressure for each pressure set impacted by this register
/// class. Normally called by RegPressureTracker, but may be called manually
/// to account for live through (global liveness).
///
/// \param Reg is either a virtual register number or register unit number.
void increase(unsigned Reg, const TargetRegisterInfo *TRI,
const MachineRegisterInfo *MRI);
/// Decrease register pressure for each pressure set impacted by this register
/// class. This is only useful to account for spilling or rematerialization.
///
/// \param Reg is either a virtual register number or register unit number.
void decrease(unsigned Reg, const TargetRegisterInfo *TRI,
const MachineRegisterInfo *MRI);
void dump(const TargetRegisterInfo *TRI) const;
};
/// RegisterPressure computed within a region of instructions delimited by
/// TopIdx and BottomIdx. During pressure computation, the maximum pressure per
/// register pressure set is increased. Once pressure within a region is fully
/// computed, the live-in and live-out sets are recorded.
///
/// This is preferable to RegionPressure when LiveIntervals are available,
/// because delimiting regions by SlotIndex is more robust and convenient than
/// holding block iterators. The block contents can change without invalidating
/// the pressure result.
struct IntervalPressure : RegisterPressure {
/// Record the boundary of the region being tracked.
SlotIndex TopIdx;
SlotIndex BottomIdx;
void reset();
void openTop(SlotIndex NextTop);
void openBottom(SlotIndex PrevBottom);
};
/// RegisterPressure computed within a region of instructions delimited by
/// TopPos and BottomPos. This is a less precise version of IntervalPressure for
/// use when LiveIntervals are unavailable.
struct RegionPressure : RegisterPressure {
/// Record the boundary of the region being tracked.
MachineBasicBlock::const_iterator TopPos;
MachineBasicBlock::const_iterator BottomPos;
void reset();
void openTop(MachineBasicBlock::const_iterator PrevTop);
void openBottom(MachineBasicBlock::const_iterator PrevBottom);
};
/// Capture a change in pressure for a single pressure set. UnitInc may be
/// expressed in terms of upward or downward pressure depending on the client
/// and will be dynamically adjusted for current liveness.
///
/// Pressure increments are tiny, typically 1-2 units, and this is only for
/// heuristics, so we don't check UnitInc overflow. Instead, we may have a
/// higher level assert that pressure is consistent within a region. We also
/// effectively ignore dead defs which don't affect heuristics much.
class PressureChange {
uint16_t PSetID; // ID+1. 0=Invalid.
int16_t UnitInc;
public:
PressureChange(): PSetID(0), UnitInc(0) {}
PressureChange(unsigned id): PSetID(id+1), UnitInc(0) {
assert(id < UINT16_MAX && "PSetID overflow.");
}
bool isValid() const { return PSetID > 0; }
unsigned getPSet() const {
assert(isValid() && "invalid PressureChange");
return PSetID - 1;
}
// If PSetID is invalid, return UINT16_MAX to give it lowest priority.
unsigned getPSetOrMax() const { return (PSetID - 1) & UINT16_MAX; }
int getUnitInc() const { return UnitInc; }
void setUnitInc(int Inc) { UnitInc = Inc; }
bool operator==(const PressureChange &RHS) const {
return PSetID == RHS.PSetID && UnitInc == RHS.UnitInc;
}
};
template <> struct isPodLike<PressureChange> {
static const bool value = true;
};
/// List of PressureChanges in order of increasing, unique PSetID.
///
/// Use a small fixed number, because we can fit more PressureChanges in an
/// empty SmallVector than ever need to be tracked per register class. If more
/// PSets are affected, then we only track the most constrained.
class PressureDiff {
// The initial design was for MaxPSets=4, but that requires PSet partitions,
// which are not yet implemented. (PSet partitions are equivalent PSets given
// the register classes actually in use within the scheduling region.)
enum { MaxPSets = 16 };
PressureChange PressureChanges[MaxPSets];
public:
typedef PressureChange* iterator;
typedef const PressureChange* const_iterator;
iterator begin() { return &PressureChanges[0]; }
iterator end() { return &PressureChanges[MaxPSets]; }
const_iterator begin() const { return &PressureChanges[0]; }
const_iterator end() const { return &PressureChanges[MaxPSets]; }
void addPressureChange(unsigned RegUnit, bool IsDec,
const MachineRegisterInfo *MRI);
};
/// Array of PressureDiffs.
class PressureDiffs {
PressureDiff *PDiffArray;
unsigned Size;
unsigned Max;
public:
PressureDiffs(): PDiffArray(0), Size(0), Max(0) {}
~PressureDiffs() { free(PDiffArray); }
void clear() { Size = 0; }
void init(unsigned N);
PressureDiff &operator[](unsigned Idx) {
assert(Idx < Size && "PressureDiff index out of bounds");
return PDiffArray[Idx];
}
const PressureDiff &operator[](unsigned Idx) const {
return const_cast<PressureDiffs*>(this)->operator[](Idx);
}
};
/// Store the effects of a change in pressure on things that MI scheduler cares
/// about.
///
/// Excess records the value of the largest difference in register units beyond
/// the target's pressure limits across the affected pressure sets, where
/// largest is defined as the absolute value of the difference. Negative
/// ExcessUnits indicates a reduction in pressure that had already exceeded the
/// target's limits.
///
/// CriticalMax records the largest increase in the tracker's max pressure that
/// exceeds the critical limit for some pressure set determined by the client.
///
/// CurrentMax records the largest increase in the tracker's max pressure that
/// exceeds the current limit for some pressure set determined by the client.
struct RegPressureDelta {
PressureChange Excess;
PressureChange CriticalMax;
PressureChange CurrentMax;
RegPressureDelta() {}
bool operator==(const RegPressureDelta &RHS) const {
return Excess == RHS.Excess && CriticalMax == RHS.CriticalMax
&& CurrentMax == RHS.CurrentMax;
}
bool operator!=(const RegPressureDelta &RHS) const {
return !operator==(RHS);
}
};
/// \brief A set of live virtual registers and physical register units.
///
/// Virtual and physical register numbers require separate sparse sets, but most
/// of the RegisterPressureTracker handles them uniformly.
struct LiveRegSet {
SparseSet<unsigned> PhysRegs;
SparseSet<unsigned, VirtReg2IndexFunctor> VirtRegs;
bool contains(unsigned Reg) const {
if (TargetRegisterInfo::isVirtualRegister(Reg))
return VirtRegs.count(Reg);
return PhysRegs.count(Reg);
}
bool insert(unsigned Reg) {
if (TargetRegisterInfo::isVirtualRegister(Reg))
return VirtRegs.insert(Reg).second;
return PhysRegs.insert(Reg).second;
}
bool erase(unsigned Reg) {
if (TargetRegisterInfo::isVirtualRegister(Reg))
return VirtRegs.erase(Reg);
return PhysRegs.erase(Reg);
}
};
/// Track the current register pressure at some position in the instruction
/// stream, and remember the high water mark within the region traversed. This
/// does not automatically consider live-through ranges. The client may
/// independently adjust for global liveness.
///
/// Each RegPressureTracker only works within a MachineBasicBlock. Pressure can
/// be tracked across a larger region by storing a RegisterPressure result at
/// each block boundary and explicitly adjusting pressure to account for block
/// live-in and live-out register sets.
///
/// RegPressureTracker holds a reference to a RegisterPressure result that it
/// computes incrementally. During downward tracking, P.BottomIdx or P.BottomPos
/// is invalid until it reaches the end of the block or closeRegion() is
/// explicitly called. Similarly, P.TopIdx is invalid during upward
/// tracking. Changing direction has the side effect of closing region, and
/// traversing past TopIdx or BottomIdx reopens it.
class RegPressureTracker {
const MachineFunction *MF;
const TargetRegisterInfo *TRI;
const RegisterClassInfo *RCI;
const MachineRegisterInfo *MRI;
const LiveIntervals *LIS;
/// We currently only allow pressure tracking within a block.
const MachineBasicBlock *MBB;
/// Track the max pressure within the region traversed so far.
RegisterPressure &P;
/// Run in two modes dependending on whether constructed with IntervalPressure
/// or RegisterPressure. If requireIntervals is false, LIS are ignored.
bool RequireIntervals;
/// True if UntiedDefs will be populated.
bool TrackUntiedDefs;
/// Register pressure corresponds to liveness before this instruction
/// iterator. It may point to the end of the block or a DebugValue rather than
/// an instruction.
MachineBasicBlock::const_iterator CurrPos;
/// Pressure map indexed by pressure set ID, not class ID.
std::vector<unsigned> CurrSetPressure;
/// Set of live registers.
LiveRegSet LiveRegs;
/// Set of vreg defs that start a live range.
SparseSet<unsigned, VirtReg2IndexFunctor> UntiedDefs;
/// Live-through pressure.
std::vector<unsigned> LiveThruPressure;
public:
RegPressureTracker(IntervalPressure &rp) :
MF(0), TRI(0), RCI(0), LIS(0), MBB(0), P(rp), RequireIntervals(true),
TrackUntiedDefs(false) {}
RegPressureTracker(RegionPressure &rp) :
MF(0), TRI(0), RCI(0), LIS(0), MBB(0), P(rp), RequireIntervals(false),
TrackUntiedDefs(false) {}
void reset();
void init(const MachineFunction *mf, const RegisterClassInfo *rci,
const LiveIntervals *lis, const MachineBasicBlock *mbb,
MachineBasicBlock::const_iterator pos,
bool ShouldTrackUntiedDefs = false);
/// Force liveness of virtual registers or physical register
/// units. Particularly useful to initialize the livein/out state of the
/// tracker before the first call to advance/recede.
void addLiveRegs(ArrayRef<unsigned> Regs);
/// Get the MI position corresponding to this register pressure.
MachineBasicBlock::const_iterator getPos() const { return CurrPos; }
// Reset the MI position corresponding to the register pressure. This allows
// schedulers to move instructions above the RegPressureTracker's
// CurrPos. Since the pressure is computed before CurrPos, the iterator
// position changes while pressure does not.
void setPos(MachineBasicBlock::const_iterator Pos) { CurrPos = Pos; }
/// \brief Get the SlotIndex for the first nondebug instruction including or
/// after the current position.
SlotIndex getCurrSlot() const;
/// Recede across the previous instruction.
bool recede(SmallVectorImpl<unsigned> *LiveUses = 0, PressureDiff *PDiff = 0);
/// Advance across the current instruction.
bool advance();
/// Finalize the region boundaries and recored live ins and live outs.
void closeRegion();
/// Initialize the LiveThru pressure set based on the untied defs found in
/// RPTracker.
void initLiveThru(const RegPressureTracker &RPTracker);
/// Copy an existing live thru pressure result.
void initLiveThru(ArrayRef<unsigned> PressureSet) {
LiveThruPressure.assign(PressureSet.begin(), PressureSet.end());
}
ArrayRef<unsigned> getLiveThru() const { return LiveThruPressure; }
/// Get the resulting register pressure over the traversed region.
/// This result is complete if either advance() or recede() has returned true,
/// or if closeRegion() was explicitly invoked.
RegisterPressure &getPressure() { return P; }
const RegisterPressure &getPressure() const { return P; }
/// Get the register set pressure at the current position, which may be less
/// than the pressure across the traversed region.
std::vector<unsigned> &getRegSetPressureAtPos() { return CurrSetPressure; }
void discoverLiveOut(unsigned Reg);
void discoverLiveIn(unsigned Reg);
bool isTopClosed() const;
bool isBottomClosed() const;
void closeTop();
void closeBottom();
/// Consider the pressure increase caused by traversing this instruction
/// bottom-up. Find the pressure set with the most change beyond its pressure
/// limit based on the tracker's current pressure, and record the number of
/// excess register units of that pressure set introduced by this instruction.
void getMaxUpwardPressureDelta(const MachineInstr *MI,
PressureDiff *PDiff,
RegPressureDelta &Delta,
ArrayRef<PressureChange> CriticalPSets,
ArrayRef<unsigned> MaxPressureLimit);
void getUpwardPressureDelta(const MachineInstr *MI,
/*const*/ PressureDiff &PDiff,
RegPressureDelta &Delta,
ArrayRef<PressureChange> CriticalPSets,
ArrayRef<unsigned> MaxPressureLimit) const;
/// Consider the pressure increase caused by traversing this instruction
/// top-down. Find the pressure set with the most change beyond its pressure
/// limit based on the tracker's current pressure, and record the number of
/// excess register units of that pressure set introduced by this instruction.
void getMaxDownwardPressureDelta(const MachineInstr *MI,
RegPressureDelta &Delta,
ArrayRef<PressureChange> CriticalPSets,
ArrayRef<unsigned> MaxPressureLimit);
/// Find the pressure set with the most change beyond its pressure limit after
/// traversing this instruction either upward or downward depending on the
/// closed end of the current region.
void getMaxPressureDelta(const MachineInstr *MI,
RegPressureDelta &Delta,
ArrayRef<PressureChange> CriticalPSets,
ArrayRef<unsigned> MaxPressureLimit) {
if (isTopClosed())
return getMaxDownwardPressureDelta(MI, Delta, CriticalPSets,
MaxPressureLimit);
assert(isBottomClosed() && "Uninitialized pressure tracker");
return getMaxUpwardPressureDelta(MI, 0, Delta, CriticalPSets,
MaxPressureLimit);
}
/// Get the pressure of each PSet after traversing this instruction bottom-up.
void getUpwardPressure(const MachineInstr *MI,
std::vector<unsigned> &PressureResult,
std::vector<unsigned> &MaxPressureResult);
/// Get the pressure of each PSet after traversing this instruction top-down.
void getDownwardPressure(const MachineInstr *MI,
std::vector<unsigned> &PressureResult,
std::vector<unsigned> &MaxPressureResult);
void getPressureAfterInst(const MachineInstr *MI,
std::vector<unsigned> &PressureResult,
std::vector<unsigned> &MaxPressureResult) {
if (isTopClosed())
return getUpwardPressure(MI, PressureResult, MaxPressureResult);
assert(isBottomClosed() && "Uninitialized pressure tracker");
return getDownwardPressure(MI, PressureResult, MaxPressureResult);
}
bool hasUntiedDef(unsigned VirtReg) const {
return UntiedDefs.count(VirtReg);
}
void dump() const;
protected:
const LiveRange *getLiveRange(unsigned Reg) const;
void increaseRegPressure(ArrayRef<unsigned> Regs);
void decreaseRegPressure(ArrayRef<unsigned> Regs);
void bumpUpwardPressure(const MachineInstr *MI);
void bumpDownwardPressure(const MachineInstr *MI);
};
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
const TargetRegisterInfo *TRI);
#endif
} // end namespace llvm
#endif
| bsd-3-clause |
HalCanary/skia-hc | tools/skp/page_sets/skia_espn_desktop.py | 1170 | # Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# pylint: disable=W0401,W0614
from telemetry import story
from telemetry.page import page as page_module
from telemetry.page import shared_page_state
class SkiaBuildbotDesktopPage(page_module.Page):
def __init__(self, url, page_set):
super(SkiaBuildbotDesktopPage, self).__init__(
url=url,
name=url,
page_set=page_set,
shared_page_state_class=shared_page_state.SharedDesktopPageState)
self.archive_data_file = 'data/skia_espn_desktop.json'
def RunNavigateSteps(self, action_runner):
action_runner.Navigate(self.url)
action_runner.Wait(5)
class SkiaEspnDesktopPageSet(story.StorySet):
""" Pages designed to represent the median, not highly optimized web """
def __init__(self):
super(SkiaEspnDesktopPageSet, self).__init__(
archive_data_file='data/skia_espn_desktop.json')
urls_list = [
# Why: #1 sports.
'http://espn.go.com',
]
for url in urls_list:
self.AddStory(SkiaBuildbotDesktopPage(url, self))
| bsd-3-clause |
awatry/libvpx.opencl | vp8/encoder/variance.h | 2799 | /*
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef VARIANCE_H
#define VARIANCE_H
typedef unsigned int(*vp8_sad_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride,
int max_sad
);
typedef void (*vp8_copy32xn_fn_t)(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride,
int n);
typedef void (*vp8_sad_multi_fn_t)(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride,
unsigned int *sad_array);
typedef void (*vp8_sad_multi1_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride,
unsigned short *sad_array
);
typedef void (*vp8_sad_multi_d_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
unsigned char *ref_ptr[4],
int ref_stride,
unsigned int *sad_array
);
typedef unsigned int (*vp8_variance_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride,
unsigned int *sse
);
typedef unsigned int (*vp8_subpixvariance_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
int xoffset,
int yoffset,
const unsigned char *ref_ptr,
int Refstride,
unsigned int *sse
);
typedef void (*vp8_ssimpf_fn_t)
(
unsigned char *s,
int sp,
unsigned char *r,
int rp,
unsigned long *sum_s,
unsigned long *sum_r,
unsigned long *sum_sq_s,
unsigned long *sum_sq_r,
unsigned long *sum_sxr
);
typedef unsigned int (*vp8_getmbss_fn_t)(const short *);
typedef unsigned int (*vp8_get16x16prederror_fn_t)
(
const unsigned char *src_ptr,
int source_stride,
const unsigned char *ref_ptr,
int ref_stride
);
typedef struct variance_vtable
{
vp8_sad_fn_t sdf;
vp8_variance_fn_t vf;
vp8_subpixvariance_fn_t svf;
vp8_variance_fn_t svf_halfpix_h;
vp8_variance_fn_t svf_halfpix_v;
vp8_variance_fn_t svf_halfpix_hv;
vp8_sad_multi_fn_t sdx3f;
vp8_sad_multi1_fn_t sdx8f;
vp8_sad_multi_d_fn_t sdx4df;
#if ARCH_X86 || ARCH_X86_64
vp8_copy32xn_fn_t copymem;
#endif
} vp8_variance_fn_ptr_t;
#endif
| bsd-3-clause |
SaschaMester/delicium | chrome/browser/collected_cookies_browsertest.cc | 2289 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/content_settings/cookie_settings_factory.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/tab_dialogs.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/url_constants.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/content_settings/core/browser/cookie_settings.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
typedef InProcessBrowserTest CollectedCookiesTest;
// If this crashes on Windows, use http://crbug.com/79331
IN_PROC_BROWSER_TEST_F(CollectedCookiesTest, DoubleDisplay) {
ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
// Disable cookies.
CookieSettingsFactory::GetForProfile(browser()->profile())
->SetDefaultCookieSetting(CONTENT_SETTING_BLOCK);
// Load a page with cookies.
ui_test_utils::NavigateToURL(
browser(), embedded_test_server()->GetURL("/cookie1.html"));
// Click on the info link twice.
content::WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
TabDialogs::FromWebContents(web_contents)->ShowCollectedCookies();
TabDialogs::FromWebContents(web_contents)->ShowCollectedCookies();
}
// If this crashes on Windows, use http://crbug.com/79331
IN_PROC_BROWSER_TEST_F(CollectedCookiesTest, NavigateAway) {
ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
// Disable cookies.
CookieSettingsFactory::GetForProfile(browser()->profile())
->SetDefaultCookieSetting(CONTENT_SETTING_BLOCK);
// Load a page with cookies.
ui_test_utils::NavigateToURL(
browser(), embedded_test_server()->GetURL("/cookie1.html"));
// Click on the info link.
content::WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
TabDialogs::FromWebContents(web_contents)->ShowCollectedCookies();
// Navigate to another page.
ui_test_utils::NavigateToURL(
browser(), embedded_test_server()->GetURL("/cookie2.html"));
}
| bsd-3-clause |
teddyzeenny/ember.js | packages/ember-old-router/lib/resolved_state.js | 985 | var get = Ember.get;
Ember._ResolvedState = Ember.Object.extend({
manager: null,
state: null,
match: null,
object: Ember.computed(function(key) {
if (this._object) {
return this._object;
} else {
var state = get(this, 'state'),
match = get(this, 'match'),
manager = get(this, 'manager');
return state.deserialize(manager, match.hash);
}
}),
hasPromise: Ember.computed(function() {
return Ember.canInvoke(get(this, 'object'), 'then');
}).property('object'),
promise: Ember.computed(function() {
var object = get(this, 'object');
if (Ember.canInvoke(object, 'then')) {
return object;
} else {
return {
then: function(success) { success(object); }
};
}
}).property('object'),
transition: function() {
var manager = get(this, 'manager'),
path = get(this, 'state.path'),
object = get(this, 'object');
manager.transitionTo(path, object);
}
});
| mit |
TedDBarr/orleans | Samples/TwitterSentiment/TwitterGrainInterfaces/ITweetGrain.cs | 1600 | /*
Project Orleans Cloud Service SDK ver. 1.0
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the ""Software""), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
using Orleans;
using Orleans.Concurrency;
using System.Threading.Tasks;
namespace TwitterGrainInterfaces
{
/// <summary>
/// A grain to act as the API into Orleans, and fan out read/writes to multiple hashtag grains
/// </summary>
public interface ITweetDispatcherGrain : IGrainWithIntegerKey
{
Task AddScore(int score, string[] hashtags, string tweet);
Task<Totals[]> GetTotals(string[] hashtags);
}
}
| mit |
Gargitier5/tier5portal | vendors/update/test/app.option.js | 2760 | require('mocha');
require('should');
var assert = require('assert');
var support = require('./support');
var App = support.resolve();
var app;
describe('app.option', function() {
beforeEach(function() {
app = new App();
});
it('should set a key-value pair on options:', function() {
app.option('a', 'b');
assert(app.options.a === 'b');
});
it('should set an object on options:', function() {
app.option({c: 'd'});
assert(app.options.c === 'd');
});
it('should set an option.', function() {
app.option('a', 'b');
app.options.should.have.property('a');
});
it('should get an option.', function() {
app.option('a', 'b');
app.option('a').should.equal('b');
});
it('should extend the `options` object.', function() {
app.option({x: 'xxx', y: 'yyy', z: 'zzz'});
app.option('x').should.equal('xxx');
app.option('y').should.equal('yyy');
app.option('z').should.equal('zzz');
});
it('options should be on the `options` object.', function() {
app.option({x: 'xxx', y: 'yyy', z: 'zzz'});
app.options.x.should.equal('xxx');
app.options.y.should.equal('yyy');
app.options.z.should.equal('zzz');
});
it('should be chainable.', function() {
app.option({x: 'xxx', y: 'yyy', z: 'zzz'});
app.option({a: 'aaa', b: 'bbb', c: 'ccc'});
app.option('x').should.equal('xxx');
app.option('a').should.equal('aaa');
});
it('should extend the `options` object when the first param is a string.', function() {
app.option('foo', {x: 'xxx', y: 'yyy', z: 'zzz'});
app.option('bar', {a: 'aaa', b: 'bbb', c: 'ccc'});
app.option('foo').should.have.property('x');
app.option('bar').should.have.property('a');
app.options.foo.should.have.property('x');
app.options.bar.should.have.property('a');
});
it('should set an option.', function() {
app.option('a', 'b');
app.options.should.have.property('a');
});
it('should get an option.', function() {
app.option('a', 'b');
app.option('a').should.equal('b');
});
it('should extend the `options` object.', function() {
app.option({x: 'xxx', y: 'yyy', z: 'zzz'});
app.option('x').should.equal('xxx');
app.option('y').should.equal('yyy');
app.option('z').should.equal('zzz');
});
it('options should be on the `options` object.', function() {
app.option({x: 'xxx', y: 'yyy', z: 'zzz'});
app.options.x.should.equal('xxx');
app.options.y.should.equal('yyy');
app.options.z.should.equal('zzz');
});
it('should be chainable.', function() {
app
.option({x: 'xxx', y: 'yyy', z: 'zzz'})
.option({a: 'aaa', b: 'bbb', c: 'ccc'});
app.option('x').should.equal('xxx');
app.option('a').should.equal('aaa');
});
});
| mit |
listrophy/mongoid | lib/mongoid/extensions/boolean/conversions.rb | 312 | # encoding: utf-8
module Mongoid #:nodoc:
module Extensions #:nodoc:
module Boolean #:nodoc:
module Conversions #:nodoc:
def set(value)
val = value.to_s
val == "true" || val == "1"
end
def get(value)
value
end
end
end
end
end
| mit |
banwang811/ZYChat | ZYChat/ZYChat/GJGCChatInputPanel/GJGCIconSeprateImageView.h | 269 | //
// GJGCIconSeprateImageView.h
// ZYChat
//
// Created by ZYVincent on 14-12-16.
// Copyright (c) 2014年 ZYProSoft. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface GJGCIconSeprateImageView : UIView
@property (nonatomic,strong)UIImage *image;
@end
| mit |
sowbiba/senegal-front | vendor/pdepend/pdepend/src/test/resources/files/Parser/testParserHandlesParentKeywordInMethodParameterDefaultValue.php | 95 | <?php
class Foo extends Bar {
public function bar($foobar = array(parent::FOOBAR)) {}
}
?>
| mit |
ssuperczynski/ngx-easy-table | src/app/demo/select-row/select-row.component.html | 163 | <div class="columns">
<div class="column col-12">
<ngx-table [configuration]="configuration" [data]="data" [columns]="columns"> </ngx-table>
</div>
</div>
| mit |
mgechev/angular | packages/common/locales/extra/nb.ts | 848 | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
const u = undefined;
export default [
[
['mn.', 'mg.', 'fm.', 'em.', 'kv.', 'nt.'],
['midn.', 'morg.', 'form.', 'etterm.', 'kveld', 'natt'],
['midnatt', 'morgenen', 'formiddagen', 'ettermiddagen', 'kvelden', 'natten']
],
[
['mn.', 'mg.', 'fm.', 'em.', 'kv.', 'nt.'],
['midn.', 'morg.', 'form.', 'etterm.', 'kveld', 'natt'],
['midnatt', 'morgen', 'formiddag', 'ettermiddag', 'kveld', 'natt']
],
[
'00:00', ['06:00', '10:00'], ['10:00', '12:00'], ['12:00', '18:00'], ['18:00', '24:00'],
['00:00', '06:00']
]
];
| mit |
chasingegg/chasingegg.github.io | themes/mogege/exampleSite/content/post/rich-content.md | 820 | +++
author = "Hugo Authors"
title = "Rich Content"
date = "2019-03-10"
description = "A brief description of Hugo Shortcodes"
tags = [
"shortcodes",
"privacy",
]
+++
Hugo ships with several [Built-in Shortcodes](https://gohugo.io/content-management/shortcodes/#use-hugo-s-built-in-shortcodes) for rich content, along with a [Privacy Config](https://gohugo.io/about/hugo-and-gdpr/) and a set of Simple Shortcodes that enable static and no-JS versions of various social media embeds.
<!--more-->
---
## Instagram Simple Shortcode
{{< instagram_simple BGvuInzyFAe hidecaption >}}
<br>
---
## YouTube Privacy Enhanced Shortcode
{{< youtube ZJthWmvUzzc >}}
<br>
---
## Twitter Simple Shortcode
{{< twitter_simple 1085870671291310081 >}}
<br>
---
## Vimeo Simple Shortcode
{{< vimeo_simple 48912912 >}}
| mit |
AquaSoftGmbH/graphviz-bin | win32/bin/config.h | 13332 | /* manually generated configuration for Windows */
#include "graphviz_version.h"
/* Command to open a browser on a URL */
#define BROWSER "xdg-open"
#define HAVE_ARGZ_APPEND 0
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
systems. This function is required for `alloca.c' support on those systems.
*/
/* #undef CRAY_STACKSEG_END */
/* Define to 1 if using `alloca.c'. */
/* #undef C_ALLOCA */
/* Define for Darwin-style shared library names. */
/* #undef DARWIN_DYLIB */
/* Default DPI. */
#define DEFAULT_DPI 96
/* Path to TrueType fonts. */
#define DEFAULT_FONTPATH "C:/WINDOWS/FONTS;C:/WINNT/Fonts;C:/winnt/fonts"
/* Define if you want DIGCOLA */
#define DIGCOLA 1
/* Define if you want on-demand plugin loading */
#define ENABLE_LTDL 1
/* Define to 1 if you have `alloca', as a function or macro. */
#define HAVE_ALLOCA 1
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
/* #undef HAVE_ALLOCA_H */
/* Define to 1 if compiler supports bool */
#define HAVE_BOOL 1
/* Define to 1 if you have the `cbrt' function. */
//#define HAVE_CBRT 1
/* Define to 1 if you have the <crt_externs.h> header file. */
/* #undef HAVE_CRT_EXTERNS_H */
/* Define to 1 if you have the `deflateBound' function. */
/* #undef HAVE_DEFLATEBOUND */
/* Define if you have the DevIL library */
/* #undef HAVE_DEVIL */
/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
*/
#define HAVE_DIRENT_H 1
/* Define to 1 if you have the <dlfcn.h> header file. */
/* #undef HAVE_DLFCN_H */
/* Define to 1 if you have the `drand48' function. */
/* #undef HAVE_DRAND48 */
/* Define if errno externs are declared */
/* #undef HAVE_ERRNO_DECL */
/* Define to 1 if you have the <errno.h> header file. */
#define HAVE_ERRNO_H 1
/* Define if you have the expat library */
#define HAVE_EXPAT 1
/* Define to 1 if you have the <expat.h> header file. */
#define HAVE_EXPAT_H 1
/* Define to 1 if you have the `feenableexcept' function. */
/* #undef HAVE_FEENABLEEXCEPT */
/* Define to 1 if you have the <fenv.h> header file. */
#define HAVE_FENV_H 1
/* Define to 1 if you have the `fesetenv' function. */
#define HAVE_FESETENV 1
/* Define if FILE structure provides _cnt */
#define HAVE_FILE_CNT 1
/* Define if FILE structure provides _IO_read_end */
/* #undef HAVE_FILE_IO_READ_END */
/* Define if FILE structure provides _next */
/* #undef HAVE_FILE_NEXT */
/* Define if FILE structure provides _r */
/* #undef HAVE_FILE_R */
/* Define to 1 if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1
/* Define if you have the fontconfig library */
#define HAVE_FONTCONFIG 1
/* Define to 1 if you have the <fpu_control.h> header file. */
/* #undef HAVE_FPU_CONTROL_H */
/* Define if you have the freetype2 library */
#define HAVE_FREETYPE2 1
/* Define if you have the GDI+ framework for Windows */
/* #undef HAVE_GDIPLUS */
/* Define if you have the gdk_pixbuf library */
/* #undef HAVE_GDK_PIXBUF */
/* Define if the GD library has the GD_FONTCONFIG feature */
#define HAVE_GD_FONTCONFIG 1
/* Define if the GD library has the GD_FREETYPE feature */
#define HAVE_GD_FREETYPE 1
/* Define if the GD library has the GD_GIF feature */
#define HAVE_GD_GIF 1
/* Define if the GD library supports GIFANIM */
/* #undef HAVE_GD_GIFANIM */
/* Define if the GD library has the GD_JPEG feature */
#define HAVE_GD_JPEG 1
/* Define if the GD library supports OPENPOLYGON */
/* #undef HAVE_GD_OPENPOLYGON */
/* Define if the GD library has the GD_PNG feature */
#define HAVE_GD_PNG 1
/* Define if the GD library supports XPM */
/* #undef HAVE_GD_XPM */
/* Define to 1 if you have the `getenv' function. */
#define HAVE_GETENV 1
/* Define if getopt externs are declared */
#define HAVE_GETOPT_DECL 1
/* Define to 1 if you have the <getopt.h> header file. */
#define HAVE_GETOPT_H 1
/* Define to 1 if you have the `getrusage' function. */
/* #undef HAVE_GETRUSAGE */
/* Define if you have the glade library */
#define HAVE_GLADE 1
/* Define if you have the glitz library */
/* #undef HAVE_GLITZ */
/* Define if you have the gs library */
/* #undef HAVE_GS */
/* Define if you have the gtk library */
/* #undef HAVE_GTK */
/* Define if you have the gtkgl library */
/* #undef HAVE_GTKGL */
/* Define if you have the gtkglext library */
#define HAVE_GTKGLEXT 1
/* Define if you have the gts library */
#define HAVE_GTS 1
/* Define if you have the iconv() function. */
#define HAVE_ICONV 1
/* Define to 1 if you have the <iconv.h> header file. */
#define HAVE_ICONV_H 1
/* Define if <iconv.h> defines iconv_t. */
#define HAVE_ICONV_T_DEF 1
/* Define to 1 if you have the <IL/il.h> header file. */
/* #undef HAVE_IL_IL_H */
/* Define if intptr_t is declared */
#define HAVE_INTPTR_T 1
/* Define to 1 if you have the <inttypes.h> header file. */
//#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the <langinfo.h> header file. */
/* #undef HAVE_LANGINFO_H */
/* Define if you have the lasi library */
/* #undef HAVE_LASI */
/* Define if either internal or external GD library is availabel */
//#define HAVE_LIBGD 1
/* Define if the LIBGEN library has the basename feature */
/* #undef HAVE_LIBGEN */
/* Define to 1 if you have the <libintl.h> header file. */
#define HAVE_LIBINTL_H 1
/* Define if you have the JPEG library */
#define HAVE_LIBJPEG 1
/* Define if you have the PNG library */
#define HAVE_LIBPNG 1
/* Define if you have the XPM library */
/* #undef HAVE_LIBXPMFORLEFTY */
/* Define if you have the Z library */
#define HAVE_LIBZ 1
/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1
/* Define to 1 if you have the `lrand48' function. */
/* #undef HAVE_LRAND48 */
/* Define to 1 if you have the `lsqrt' function. */
/* #undef HAVE_LSQRT */
/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1
/* Define if you have the ming library for SWF support */
/* #undef HAVE_MING */
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
/* #undef HAVE_NDIR_H */
/* Define to 1 if you have the `nl_langinfo' function. */
/* #undef HAVE_NL_LANGINFO */
/* Define if you have the pangocairo library */
#define HAVE_PANGOCAIRO 1
/* Define to 1 if you have the `pango_fc_font_lock_face' function. */
/* #undef HAVE_PANGO_FC_FONT_LOCK_FACE */
/* Define to 1 if you have the `pango_fc_font_unlock_face' function. */
/* #undef HAVE_PANGO_FC_FONT_UNLOCK_FACE */
/* Define to 1 if you have the `pow' function. */
#define HAVE_POW 1
/* Define to 1 if you have the <pthread.h> header file. */
/* #undef HAVE_PTHREAD_H */
/* Define if you have the Quartz framework for Mac OS X */
/* #undef HAVE_QUARTZ */
/* Define if you have the rsvg library */
#define HAVE_RSVG 1
/* Define to 1 if you have the <search.h> header file. */
#define HAVE_SEARCH_H 1
/* Define to 1 if you have the `setenv' function. */
/* #undef HAVE_SETENV */
/* Define to 1 if you have the <setjmp.h> header file. */
#define HAVE_SETJMP_H 1
/* Define to 1 if you have the `setmode' function. */
#define HAVE_SETMODE 1
/* Define if libm provides a *working* sincos function */
/* #undef HAVE_SINCOS */
/* Define to 1 if you have the `sqrt' function. */
#define HAVE_SQRT 1
/* Define to 1 if you have the `srand48' function. */
/* #undef HAVE_SRAND48 */
/* Define to 1 if you have the <stdarg.h> header file. */
#define HAVE_STDARG_H 1
/* Define to 1 if stdbool.h conforms to C99. */
//#define HAVE_STDBOOL_H 1
/* Define to 1 if you have the <stddef.h> header file. */
#define HAVE_STDDEF_H 1
/* Define to 1 if you have the <stdint.h> header file. */
//#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the `strcasecmp' function. */
//#define HAVE_STRCASECMP 1
/* Define to 1 if you have the `strchr' function. */
#define HAVE_STRCHR 1
/* Define to 1 if you have the `strdup' function. */
#define HAVE_STRDUP 1
/* Define to 1 if you have the `strerror' function. */
#define HAVE_STRERROR 1
/* Define to 1 if you have the <strings.h> header file. */
//#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strncasecmp' function. */
//#define HAVE_STRNCASECMP 1
/* Define to 1 if you have the `strstr' function. */
#define HAVE_STRSTR 1
/* Define to 1 if you have the `strtoll' function. */
#define HAVE_STRTOLL 1
/* Define to 1 if you have the `strtoul' function. */
#define HAVE_STRTOUL 1
/* Define to 1 if you have the `strtoull' function. */
#define HAVE_STRTOULL 1
/* Define to 1 if you have struct dioattr */
/* #undef HAVE_STRUCT_DIOATTR */
/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_DIR_H */
/* Define to 1 if you have the <sys/fpu.h> header file. */
/* #undef HAVE_SYS_FPU_H */
/* Define to 1 if you have the <sys/inotify.h> header file. */
/* #undef HAVE_SYS_INOTIFY_H */
/* Define to 1 if you have the <sys/ioctl.h> header file. */
/* #undef HAVE_SYS_IOCTL_H */
/* Define to 1 if you have the <sys/mman.h> header file. */
/* #undef HAVE_SYS_MMAN_H */
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_NDIR_H */
/* Define to 1 if you have the <sys/select.h> header file. */
/* #undef HAVE_SYS_SELECT_H */
/* Define to 1 if you have the <sys/socket.h> header file. */
/* #undef HAVE_SYS_SOCKET_H */
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/times.h> header file. */
/* #undef HAVE_SYS_TIMES_H */
/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define if you have the tcl library */
/* #undef HAVE_TCL */
/* Define to 1 if you have the <termios.h> header file. */
/* #undef HAVE_TERMIOS_H */
/* Define to 1 if you have the <time.h> header file. */
#define HAVE_TIME_H 1
/* Define to 1 if you have the <tkInt.h> header file. */
/* #undef HAVE_TKINT_H */
/* Define to 1 if you have the <tk.h> header file. */
/* #undef HAVE_TK_H */
/* Define if triangle.[ch] are available. */
/* #undef HAVE_TRIANGLE */
/* Define to 1 if you have the `uname' function. */
/* #undef HAVE_UNAME */
/* Define to 1 if you have the <unistd.h> header file. */
//#define HAVE_UNISTD_H 1
/* Define to 1 if you have the <values.h> header file. */
//#define HAVE_VALUES_H 1
/* Define to 1 if you have the `vsnprintf' function. */
#define HAVE_VSNPRINTF 1
/* Define to 1 if you have the <X11/Intrinsic.h> header file. */
/* #undef HAVE_X11_INTRINSIC_H */
/* Define to 1 if you have the <X11/Xaw/Text.h> header file. */
/* #undef HAVE_X11_XAW_TEXT_H */
/* Define to 1 if the system has the type `_Bool'. */
#define HAVE__BOOL 1
/* Define to 1 if you have the `_NSGetEnviron' function. */
/* #undef HAVE__NSGETENVIRON */
/* Define to 1 if you have the `_sysconf' function. */
/* #undef HAVE__SYSCONF */
/* Define to 1 if you have the `__freadable' function. */
/* #undef HAVE___FREADABLE */
/* Define as const if the declaration of iconv() needs const. */
#define ICONV_CONST const
/* Define if you want IPSEPCOLA */
/* #undef IPSEPCOLA */
#define IPSEPCOLA 1
/* Define if no fpu error exception handling is required. */
#define NO_FPERR 1
/* Postscript fontnames. */
#define NO_POSTSCRIPT_ALIAS 1
/* Define if you want ORTHO */
/* #undef ORTHO */
#define ORTHO 1
/* Path separator character. */
#define PATHSEPARATOR ":"
/* Define if you want SFDP */
#define SFDP 1
/* #undef SFDP */
/* Define if you want SMYRNA */
/* #undef SMYRNA */
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
#define TIME_WITH_SYS_TIME 1
/* Define if you want CGRAPH */
/* #undef WITH_CGRAPH */
/* Define to 1 if the X Window System is missing or not being used. */
#define X_DISPLAY_MISSING 1
/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
`char[]'. */
/* #undef YYTEXT_POINTER */
/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */
/* Define to `int' if <sys/types.h> doesn't define. */
#define gid_t int
/* Define to `int' if <sys/types.h> does not define. */
/* #undef mode_t */
/* Define to `int' if <sys/types.h> does not define. */
/* #undef pid_t */
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
/* Define to unsigned if socklet_t is missing */
#define socklen_t unsigned
/* Define to `int' if <sys/types.h> does not define. */
//#define ssize_t int
/* Define to `int' if <sys/types.h> doesn't define. */
#define uid_t int
| epl-1.0 |
TheOrchardSolutions/WordPress | wp-content/plugins/wp-to-buffer/_modules/dashboard/views/sidebar-upgrade.php | 1049 | <?php
/**
* Settings screen sidebar for free plugins with a pro version. Display the reasons to upgrade
* and the mailing list.
*/
?>
<!-- Keep Updated -->
<div class="postbox">
<div class="handlediv" title="Click to toggle"><br /></div>
<h3 class="hndle"><span><?php _e('Keep Updated', $this->plugin->name); ?></span></h3>
<div class="option">
<p class="description"><?php _e('Subscribe to the newsletter and receive updates on our WordPress Plugins', $this->plugin->name); ?>.</p>
</div>
<form action="http://n7studios.createsend.com/t/r/s/jdutdyj/" method="post">
<div class="option">
<p>
<strong><?php _e('Email', $this->plugin->name); ?></strong>
<input id="fieldEmail" name="cm-jdutdyj-jdutdyj" type="email" required />
</p>
</div>
<div class="option">
<p>
<input type="submit" name="submit" value="<?php _e('Subscribe', $this->plugin->name); ?>" class="button button-primary" />
</p>
</div>
</form>
</div> | gpl-2.0 |
ZephyrSurfer/dolphin | Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/adapters/SettingsRowPresenter.java | 1484 | // SPDX-License-Identifier: GPL-2.0-or-later
package org.dolphinemu.dolphinemu.adapters;
import android.content.res.Resources;
import android.view.ViewGroup;
import androidx.leanback.widget.ImageCardView;
import androidx.leanback.widget.Presenter;
import org.dolphinemu.dolphinemu.model.TvSettingsItem;
import org.dolphinemu.dolphinemu.viewholders.TvSettingsViewHolder;
public final class SettingsRowPresenter extends Presenter
{
public Presenter.ViewHolder onCreateViewHolder(ViewGroup parent)
{
// Create a new view.
ImageCardView settingsCard = new ImageCardView(parent.getContext());
settingsCard.setMainImageAdjustViewBounds(true);
settingsCard.setMainImageDimensions(192, 160);
settingsCard.setFocusable(true);
settingsCard.setFocusableInTouchMode(true);
// Use that view to create a ViewHolder.
return new TvSettingsViewHolder(settingsCard);
}
public void onBindViewHolder(Presenter.ViewHolder viewHolder, Object item)
{
TvSettingsViewHolder holder = (TvSettingsViewHolder) viewHolder;
TvSettingsItem settingsItem = (TvSettingsItem) item;
Resources resources = holder.cardParent.getResources();
holder.itemId = settingsItem.getItemId();
holder.cardParent.setTitleText(resources.getString(settingsItem.getLabelId()));
holder.cardParent.setMainImage(resources.getDrawable(settingsItem.getIconId(), null));
}
public void onUnbindViewHolder(Presenter.ViewHolder viewHolder)
{
// no op
}
}
| gpl-2.0 |
somaen/scummvm | engines/wintermute/ext/dll_httpconnect.cpp | 8196 | /* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
/*
* This file is based on WME Lite.
* http://dead-code.org/redir.php?target=wmelite
* Copyright (c) 2011 Jan Nedoma
*/
#include "engines/wintermute/base/base_game.h"
#include "engines/wintermute/base/base_scriptable.h"
#include "engines/wintermute/base/scriptables/script.h"
#include "engines/wintermute/base/scriptables/script_value.h"
#include "engines/wintermute/base/scriptables/script_stack.h"
namespace Wintermute {
bool EmulateHTTPConnectExternalCalls(BaseGame *inGame, ScStack *stack, ScStack *thisStack, ScScript::TExternalFunction *function) {
//////////////////////////////////////////////////////////////////////////
// Register
// Used to register license key online at Pizza Morgana: Episode 1 - Monsters and Manipulations in the Magical Forest
// Specification: external "httpconnect.dll" cdecl long Register(string, long, string, long)
// Known usage: Register(<productId>, 65535, <productKey>, 65535)
// Known product ID values are: "357868", "353058" and "353006"
// Known action: HTTP GET http://keygen.corbomitegames.com/keygen/validateKey.php?action=REGISTER&productId=productId&key=productKey
// Returns 1 on success
// Returns 0 on firewall error
// Returns -1 on invalid product key
// Returns -2 on invalid product ID
// Returns -3 on expired product key
// Returns -4 on invalid machine ID
// Returns -5 on number of installations exceeded
// Returns -6 on socket error
// Returns -7 on no internet connection
// Returns -8 on connection reset
// Returns -11 on validation temporary unavaliable
// Returns -12 on validation error
// For some reason always returns -7 for me in a test game
//////////////////////////////////////////////////////////////////////////
if (strcmp(function->name, "Register") == 0) {
stack->correctParams(4);
const char *productId = stack->pop()->getString();
int productIdMaxLen = stack->pop()->getInt();
const char *productKey = stack->pop()->getString();
int productKeyMaxLen = stack->pop()->getInt();
warning("Register(\"%s\",%d,\"%s\",%d) is not implemented", productId , productIdMaxLen, productKey, productKeyMaxLen);
stack->pushInt(-7); // "no internet connection" error
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// Validate
// Used to validate something at Pizza Morgana: Episode 1 - Monsters and Manipulations in the Magical Forest
// Specification: external "httpconnect.dll" cdecl long Validate()
// Known usage: Validate()
// Known action: HTTP GET http://keygen.corbomitegames.com/keygen/validateKey.php?action=VALIDATE&productId=Ar&key=Ar
// Used only when Debug mode is active or game is started with "INVALID" cmdline parameter
// For some reason always returns 1 for me in a test game
//////////////////////////////////////////////////////////////////////////
else if (strcmp(function->name, "Validate") == 0) {
stack->correctParams(0);
// do nothing
stack->pushInt(1);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// SendHTTPAsync
// Used to send game progress events to server at Pizza Morgana: Episode 1 - Monsters and Manipulations in the Magical Forest
// Specification: external "httpconnect.dll" cdecl long SendHTTPAsync(string, long, string, long, string, long)
// Known usage: SendHTTPAsync("backend.pizzamorgana.com", 65535, <FullURL>, 65535, <Buffer?!>, 65535)
// FullURL is formed as "http://backend.pizzamorgana.com/event.php?Event=<EventName>&player=<PlayerName>&extraParams=<ExtraParams>&SN=<ProductKey>&Episode=1&GameTime=<CurrentTime>&UniqueID=<UniqueId>"
// Known EventName values are: "GameStart", "ChangeGoal", "EndGame" and "QuitGame"
// Known ExtraParams values are: "ACT0", "ACT1", "ACT2", "ACT3", "ACT4", "Ep0FindFood", "Ep0FindCellMenu", "Ep0BroRoom", "Ep0FindKey", "Ep0FindCellMenuKey", "Ep0FindMenuKey", "Ep0FindCell", "Ep0FindMenu", "Ep0OrderPizza", "Ep0GetRidOfVamp", "Ep0GetVampAttention", "Ep0License"
// Return value is never used
//////////////////////////////////////////////////////////////////////////
else if (strcmp(function->name, "SendHTTPAsync") == 0) {
stack->correctParams(6);
const char *server = stack->pop()->getString();
int serverMaxLen = stack->pop()->getInt();
const char *fullUrl = stack->pop()->getString();
int fullUrlMaxLen = stack->pop()->getInt();
const char *param5 = stack->pop()->getString();
int param5MaxLen = stack->pop()->getInt();
// TODO: Maybe parse URL and call some Achievements API using ExtraParams values in some late future
warning("SendHTTPAsync(\"%s\",%d,\"%s\",%d,\"%s\",%d) is not implemented", server, serverMaxLen, fullUrl, fullUrlMaxLen, param5, param5MaxLen);
stack->pushInt(0);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// SendRecvHTTP (6 params variant)
// Declared at Pizza Morgana: Episode 1 - Monsters and Manipulations in the Magical Forest
// Seems to be unused, probably SendRecvHTTP was initially used instead of SendHTTPAsync
// Specification: external "httpconnect.dll" cdecl long SendRecvHTTP(string, long, string, long, string, long)
// Always returns -7 for me in a test game, probably returns the same network errors as Register()
//////////////////////////////////////////////////////////////////////////
else if (strcmp(function->name, "SendRecvHTTP") == 0 && function->nu_params == 6) {
stack->correctParams(6);
const char *server = stack->pop()->getString();
int serverMaxLen = stack->pop()->getInt();
const char *fullUrl = stack->pop()->getString();
int fullUrlMaxLen = stack->pop()->getInt();
const char *param5 = stack->pop()->getString();
int param5MaxLen = stack->pop()->getInt();
warning("SendRecvHTTP(\"%s\",%d,\"%s\",%d,\"%s\",%d) is not implemented", server, serverMaxLen, fullUrl, fullUrlMaxLen, param5, param5MaxLen);
stack->pushInt(-7); // "no internet connection" error
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// SendRecvHTTP (4 params variant)
// Used to call HTTP methods at Zbang! The Game
// Specification: external "httpconnect.dll" cdecl long SendRecvHTTP(string, long, string, long)
// Known usage: SendRecvHTTP("scoresshort.php?player=<PlayerName>", 65535, <Buffer>, 65535)
// Known usage: SendRecvHTTP("/update.php?player=<PlayerName>&difficulty=<Difficulty>&items=<CommaSeparatedItemList>", 65535, <Buffer>, 65535)
// My Zbang demo does not have this dll, so there is no way to actually test it with a test game
// Return value is never used in Zbang scripts
//////////////////////////////////////////////////////////////////////////
else if (strcmp(function->name, "SendRecvHTTP") == 0 && function->nu_params == 4) {
stack->correctParams(4);
const char *dirUrl = stack->pop()->getString();
int dirUrlMaxLen = stack->pop()->getInt();
/*ScValue *buf =*/ stack->pop();
int bufMaxLen = stack->pop()->getInt();
//TODO: Count items and give scores, persist those values
warning("SendRecvHTTP(\"%s\",%d,buf,%d) is not implemented", dirUrl, dirUrlMaxLen, bufMaxLen);
stack->pushInt(0);
return STATUS_OK;
}
return STATUS_FAILED;
}
} // End of namespace Wintermute
| gpl-2.0 |
Jackeagle/android_kernel_huawei_msm8916 | include/linux/mmzone.h | 41373 | #ifndef _LINUX_MMZONE_H
#define _LINUX_MMZONE_H
#ifndef __ASSEMBLY__
#ifndef __GENERATING_BOUNDS_H
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/wait.h>
#include <linux/bitops.h>
#include <linux/cache.h>
#include <linux/threads.h>
#include <linux/numa.h>
#include <linux/init.h>
#include <linux/seqlock.h>
#include <linux/nodemask.h>
#include <linux/pageblock-flags.h>
#include <linux/page-flags-layout.h>
#include <linux/atomic.h>
#include <asm/page.h>
/* Free memory management - zoned buddy allocator. */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
/*
* PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
* costly to service. That is between allocation orders which should
* coalesce naturally under reasonable reclaim pressure and those which
* will not.
*/
#define PAGE_ALLOC_COSTLY_ORDER 3
enum {
MIGRATE_UNMOVABLE,
MIGRATE_RECLAIMABLE,
MIGRATE_MOVABLE,
MIGRATE_PCPTYPES, /* the number of types on the pcp lists */
MIGRATE_RESERVE = MIGRATE_PCPTYPES,
#ifdef CONFIG_CMA
/*
* MIGRATE_CMA migration type is designed to mimic the way
* ZONE_MOVABLE works. Only movable pages can be allocated
* from MIGRATE_CMA pageblocks and page allocator never
* implicitly change migration type of MIGRATE_CMA pageblock.
*
* The way to use it is to change migratetype of a range of
* pageblocks to MIGRATE_CMA which can be done by
* __free_pageblock_cma() function. What is important though
* is that a range of pageblocks must be aligned to
* MAX_ORDER_NR_PAGES should biggest page be bigger then
* a single pageblock.
*/
MIGRATE_CMA,
#endif
#ifdef CONFIG_MEMORY_ISOLATION
MIGRATE_ISOLATE, /* can't allocate from here */
#endif
MIGRATE_TYPES
};
/*
* Returns a list which contains the migrate types on to which
* an allocation falls back when the free list for the migrate
* type mtype is depleted.
* The end of the list is delimited by the type MIGRATE_RESERVE.
*/
extern int *get_migratetype_fallbacks(int mtype);
#ifdef CONFIG_CMA
bool is_cma_pageblock(struct page *page);
# define is_migrate_cma(migratetype) unlikely((migratetype) == MIGRATE_CMA)
#else
# define is_cma_pageblock(page) false
# define is_migrate_cma(migratetype) false
#endif
#define for_each_migratetype_order(order, type) \
for (order = 0; order < MAX_ORDER; order++) \
for (type = 0; type < MIGRATE_TYPES; type++)
extern int page_group_by_mobility_disabled;
static inline int get_pageblock_migratetype(struct page *page)
{
return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
}
struct free_area {
struct list_head free_list[MIGRATE_TYPES];
unsigned long nr_free;
};
struct pglist_data;
/*
* zone->lock and zone->lru_lock are two of the hottest locks in the kernel.
* So add a wild amount of padding here to ensure that they fall into separate
* cachelines. There are very few zone structures in the machine, so space
* consumption is not a concern here.
*/
#if defined(CONFIG_SMP)
struct zone_padding {
char x[0];
} ____cacheline_internodealigned_in_smp;
#define ZONE_PADDING(name) struct zone_padding name;
#else
#define ZONE_PADDING(name)
#endif
enum zone_stat_item {
/* First 128 byte cacheline (assuming 64 bit words) */
NR_FREE_PAGES,
NR_LRU_BASE,
NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */
NR_ACTIVE_ANON, /* " " " " " */
NR_INACTIVE_FILE, /* " " " " " */
NR_ACTIVE_FILE, /* " " " " " */
NR_UNEVICTABLE, /* " " " " " */
NR_MLOCK, /* mlock()ed pages found and moved off LRU */
NR_ANON_PAGES, /* Mapped anonymous pages */
NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
only modified from process context */
NR_FILE_PAGES,
NR_FILE_DIRTY,
NR_WRITEBACK,
NR_SLAB_RECLAIMABLE,
NR_SLAB_UNRECLAIMABLE,
NR_PAGETABLE, /* used for pagetables */
NR_KERNEL_STACK,
/* Second 128 byte cacheline */
NR_UNSTABLE_NFS, /* NFS unstable pages */
NR_BOUNCE,
NR_VMSCAN_WRITE,
NR_VMSCAN_IMMEDIATE, /* Prioritise for reclaim when writeback ends */
NR_WRITEBACK_TEMP, /* Writeback using temporary buffers */
NR_ISOLATED_ANON, /* Temporary isolated pages from anon lru */
NR_ISOLATED_FILE, /* Temporary isolated pages from file lru */
NR_SHMEM, /* shmem pages (included tmpfs/GEM pages) */
NR_DIRTIED, /* page dirtyings since bootup */
NR_WRITTEN, /* page writings since bootup */
#ifdef CONFIG_NUMA
NUMA_HIT, /* allocated in intended node */
NUMA_MISS, /* allocated in non intended node */
NUMA_FOREIGN, /* was intended here, hit elsewhere */
NUMA_INTERLEAVE_HIT, /* interleaver preferred this zone */
NUMA_LOCAL, /* allocation from local node */
NUMA_OTHER, /* allocation from other node */
#endif
NR_ANON_TRANSPARENT_HUGEPAGES,
NR_FREE_CMA_PAGES,
NR_VM_ZONE_STAT_ITEMS };
/*
* We do arithmetic on the LRU lists in various places in the code,
* so it is important to keep the active lists LRU_ACTIVE higher in
* the array than the corresponding inactive lists, and to keep
* the *_FILE lists LRU_FILE higher than the corresponding _ANON lists.
*
* This has to be kept in sync with the statistics in zone_stat_item
* above and the descriptions in vmstat_text in mm/vmstat.c
*/
#define LRU_BASE 0
#define LRU_ACTIVE 1
#define LRU_FILE 2
enum lru_list {
LRU_INACTIVE_ANON = LRU_BASE,
LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
LRU_UNEVICTABLE,
NR_LRU_LISTS
};
#define for_each_lru(lru) for (lru = 0; lru < NR_LRU_LISTS; lru++)
#define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)
static inline int is_file_lru(enum lru_list lru)
{
return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
}
static inline int is_active_lru(enum lru_list lru)
{
return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);
}
static inline int is_unevictable_lru(enum lru_list lru)
{
return (lru == LRU_UNEVICTABLE);
}
struct zone_reclaim_stat {
/*
* The pageout code in vmscan.c keeps track of how many of the
* mem/swap backed and file backed pages are referenced.
* The higher the rotated/scanned ratio, the more valuable
* that cache is.
*
* The anon LRU stats live in [0], file LRU stats in [1]
*/
unsigned long recent_rotated[2];
unsigned long recent_scanned[2];
};
struct lruvec {
struct list_head lists[NR_LRU_LISTS];
struct zone_reclaim_stat reclaim_stat;
#ifdef CONFIG_MEMCG
struct zone *zone;
#endif
};
/* Mask used at gathering information at once (see memcontrol.c) */
#define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
#define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
#define LRU_ALL ((1 << NR_LRU_LISTS) - 1)
/* Isolate clean file */
#define ISOLATE_CLEAN ((__force isolate_mode_t)0x1)
/* Isolate unmapped file */
#define ISOLATE_UNMAPPED ((__force isolate_mode_t)0x2)
/* Isolate for asynchronous migration */
#define ISOLATE_ASYNC_MIGRATE ((__force isolate_mode_t)0x4)
/* Isolate unevictable pages */
#define ISOLATE_UNEVICTABLE ((__force isolate_mode_t)0x8)
/* LRU Isolation modes. */
typedef unsigned __bitwise__ isolate_mode_t;
enum zone_watermarks {
WMARK_MIN,
WMARK_LOW,
WMARK_HIGH,
NR_WMARK
};
#define min_wmark_pages(z) (z->watermark[WMARK_MIN])
#define low_wmark_pages(z) (z->watermark[WMARK_LOW])
#define high_wmark_pages(z) (z->watermark[WMARK_HIGH])
struct per_cpu_pages {
int count; /* number of pages in the list */
int high; /* high watermark, emptying needed */
int batch; /* chunk size for buddy add/remove */
/* Lists of pages, one per migrate type stored on the pcp-lists */
struct list_head lists[MIGRATE_PCPTYPES];
};
struct per_cpu_pageset {
struct per_cpu_pages pcp;
#ifdef CONFIG_NUMA
s8 expire;
#endif
#ifdef CONFIG_SMP
s8 stat_threshold;
s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
#endif
};
#endif /* !__GENERATING_BOUNDS.H */
enum zone_type {
#ifdef CONFIG_ZONE_DMA
/*
* ZONE_DMA is used when there are devices that are not able
* to do DMA to all of addressable memory (ZONE_NORMAL). Then we
* carve out the portion of memory that is needed for these devices.
* The range is arch specific.
*
* Some examples
*
* Architecture Limit
* ---------------------------
* parisc, ia64, sparc <4G
* s390 <2G
* arm Various
* alpha Unlimited or 0-16MB.
*
* i386, x86_64 and multiple other arches
* <16M.
*/
ZONE_DMA,
#endif
#ifdef CONFIG_ZONE_DMA32
/*
* x86_64 needs two ZONE_DMAs because it supports devices that are
* only able to do DMA to the lower 16M but also 32 bit devices that
* can only do DMA areas below 4G.
*/
ZONE_DMA32,
#endif
/*
* Normal addressable memory is in ZONE_NORMAL. DMA operations can be
* performed on pages in ZONE_NORMAL if the DMA devices support
* transfers to all addressable memory.
*/
ZONE_NORMAL,
#ifdef CONFIG_HIGHMEM
/*
* A memory area that is only addressable by the kernel through
* mapping portions into its own address space. This is for example
* used by i386 to allow the kernel to address the memory beyond
* 900MB. The kernel will set up special mappings (page
* table entries on i386) for each page that the kernel needs to
* access.
*/
ZONE_HIGHMEM,
#endif
ZONE_MOVABLE,
__MAX_NR_ZONES
};
#ifndef __GENERATING_BOUNDS_H
struct zone {
/* Fields commonly accessed by the page allocator */
/* zone watermarks, access with *_wmark_pages(zone) macros */
unsigned long watermark[NR_WMARK];
/*
* When free pages are below this point, additional steps are taken
* when reading the number of free pages to avoid per-cpu counter
* drift allowing watermarks to be breached
*/
unsigned long percpu_drift_mark;
/*
* We don't know if the memory that we're going to allocate will be freeable
* or/and it will be released eventually, so to avoid totally wasting several
* GB of ram we must reserve some of the lower zone memory (otherwise we risk
* to run OOM on the lower zones despite there's tons of freeable ram
* on the higher zones). This array is recalculated at runtime if the
* sysctl_lowmem_reserve_ratio sysctl changes.
*/
unsigned long lowmem_reserve[MAX_NR_ZONES];
/*
* This is a per-zone reserve of pages that should not be
* considered dirtyable memory.
*/
unsigned long dirty_balance_reserve;
#ifdef CONFIG_NUMA
int node;
/*
* zone reclaim becomes active if more unmapped pages exist.
*/
unsigned long min_unmapped_pages;
unsigned long min_slab_pages;
#endif
struct per_cpu_pageset __percpu *pageset;
/*
* free areas of different sizes
*/
spinlock_t lock;
#if defined CONFIG_COMPACTION || defined CONFIG_CMA
/* Set to true when the PG_migrate_skip bits should be cleared */
bool compact_blockskip_flush;
/* pfns where compaction scanners should start */
unsigned long compact_cached_free_pfn;
unsigned long compact_cached_migrate_pfn;
#endif
#ifdef CONFIG_MEMORY_HOTPLUG
/* see spanned/present_pages for more description */
seqlock_t span_seqlock;
#endif
#ifdef CONFIG_CMA
bool cma_alloc;
#endif
struct free_area free_area[MAX_ORDER];
#ifndef CONFIG_SPARSEMEM
/*
* Flags for a pageblock_nr_pages block. See pageblock-flags.h.
* In SPARSEMEM, this map is stored in struct mem_section
*/
unsigned long *pageblock_flags;
#endif /* CONFIG_SPARSEMEM */
#ifdef CONFIG_COMPACTION
/*
* On compaction failure, 1<<compact_defer_shift compactions
* are skipped before trying again. The number attempted since
* last failure is tracked with compact_considered.
*/
unsigned int compact_considered;
unsigned int compact_defer_shift;
int compact_order_failed;
#endif
ZONE_PADDING(_pad1_)
/* Fields commonly accessed by the page reclaim scanner */
spinlock_t lru_lock;
struct lruvec lruvec;
unsigned long pages_scanned; /* since last reclaim */
unsigned long flags; /* zone flags, see below */
/* Zone statistics */
atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
/*
* The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
* this zone's LRU. Maintained by the pageout code.
*/
unsigned int inactive_ratio;
ZONE_PADDING(_pad2_)
/* Rarely used or read-mostly fields */
/*
* wait_table -- the array holding the hash table
* wait_table_hash_nr_entries -- the size of the hash table array
* wait_table_bits -- wait_table_size == (1 << wait_table_bits)
*
* The purpose of all these is to keep track of the people
* waiting for a page to become available and make them
* runnable again when possible. The trouble is that this
* consumes a lot of space, especially when so few things
* wait on pages at a given time. So instead of using
* per-page waitqueues, we use a waitqueue hash table.
*
* The bucket discipline is to sleep on the same queue when
* colliding and wake all in that wait queue when removing.
* When something wakes, it must check to be sure its page is
* truly available, a la thundering herd. The cost of a
* collision is great, but given the expected load of the
* table, they should be so rare as to be outweighed by the
* benefits from the saved space.
*
* __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
* primary users of these fields, and in mm/page_alloc.c
* free_area_init_core() performs the initialization of them.
*/
wait_queue_head_t * wait_table;
unsigned long wait_table_hash_nr_entries;
unsigned long wait_table_bits;
/*
* Discontig memory support fields.
*/
struct pglist_data *zone_pgdat;
/* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
unsigned long zone_start_pfn;
/*
* spanned_pages is the total pages spanned by the zone, including
* holes, which is calculated as:
* spanned_pages = zone_end_pfn - zone_start_pfn;
*
* present_pages is physical pages existing within the zone, which
* is calculated as:
* present_pages = spanned_pages - absent_pages(pages in holes);
*
* managed_pages is present pages managed by the buddy system, which
* is calculated as (reserved_pages includes pages allocated by the
* bootmem allocator):
* managed_pages = present_pages - reserved_pages;
*
* So present_pages may be used by memory hotplug or memory power
* management logic to figure out unmanaged pages by checking
* (present_pages - managed_pages). And managed_pages should be used
* by page allocator and vm scanner to calculate all kinds of watermarks
* and thresholds.
*
* Locking rules:
*
* zone_start_pfn and spanned_pages are protected by span_seqlock.
* It is a seqlock because it has to be read outside of zone->lock,
* and it is done in the main allocator path. But, it is written
* quite infrequently.
*
* The span_seq lock is declared along with zone->lock because it is
* frequently read in proximity to zone->lock. It's good to
* give them a chance of being in the same cacheline.
*
* Write access to present_pages at runtime should be protected by
* lock_memory_hotplug()/unlock_memory_hotplug(). Any reader who can't
* tolerant drift of present_pages should hold memory hotplug lock to
* get a stable value.
*
* Read access to managed_pages should be safe because it's unsigned
* long. Write access to zone->managed_pages and totalram_pages are
* protected by managed_page_count_lock at runtime. Idealy only
* adjust_managed_page_count() should be used instead of directly
* touching zone->managed_pages and totalram_pages.
*/
unsigned long spanned_pages;
unsigned long present_pages;
unsigned long managed_pages;
/*
* rarely used fields:
*/
const char *name;
} ____cacheline_internodealigned_in_smp;
typedef enum {
ZONE_RECLAIM_LOCKED, /* prevents concurrent reclaim */
ZONE_OOM_LOCKED, /* zone is in OOM killer zonelist */
ZONE_CONGESTED, /* zone has many dirty pages backed by
* a congested BDI
*/
ZONE_TAIL_LRU_DIRTY, /* reclaim scanning has recently found
* many dirty file pages at the tail
* of the LRU.
*/
ZONE_WRITEBACK, /* reclaim scanning has recently found
* many pages under writeback
*/
} zone_flags_t;
static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
{
set_bit(flag, &zone->flags);
}
static inline int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
{
return test_and_set_bit(flag, &zone->flags);
}
static inline void zone_clear_flag(struct zone *zone, zone_flags_t flag)
{
clear_bit(flag, &zone->flags);
}
static inline int zone_is_reclaim_congested(const struct zone *zone)
{
return test_bit(ZONE_CONGESTED, &zone->flags);
}
static inline int zone_is_reclaim_dirty(const struct zone *zone)
{
return test_bit(ZONE_TAIL_LRU_DIRTY, &zone->flags);
}
static inline int zone_is_reclaim_writeback(const struct zone *zone)
{
return test_bit(ZONE_WRITEBACK, &zone->flags);
}
static inline int zone_is_reclaim_locked(const struct zone *zone)
{
return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
}
static inline int zone_is_oom_locked(const struct zone *zone)
{
return test_bit(ZONE_OOM_LOCKED, &zone->flags);
}
static inline unsigned long zone_end_pfn(const struct zone *zone)
{
return zone->zone_start_pfn + zone->spanned_pages;
}
static inline bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
{
return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
}
static inline bool zone_is_initialized(struct zone *zone)
{
return !!zone->wait_table;
}
static inline bool zone_is_empty(struct zone *zone)
{
return zone->spanned_pages == 0;
}
/*
* The "priority" of VM scanning is how much of the queues we will scan in one
* go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
* queues ("queue_length >> 12") during an aging round.
*/
#define DEF_PRIORITY 12
/* Maximum number of zones on a zonelist */
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)
#ifdef CONFIG_NUMA
/*
* The NUMA zonelists are doubled because we need zonelists that restrict the
* allocations to a single node for GFP_THISNODE.
*
* [0] : Zonelist with fallback
* [1] : No fallback (GFP_THISNODE)
*/
#define MAX_ZONELISTS 2
/*
* We cache key information from each zonelist for smaller cache
* footprint when scanning for free pages in get_page_from_freelist().
*
* 1) The BITMAP fullzones tracks which zones in a zonelist have come
* up short of free memory since the last time (last_fullzone_zap)
* we zero'd fullzones.
* 2) The array z_to_n[] maps each zone in the zonelist to its node
* id, so that we can efficiently evaluate whether that node is
* set in the current tasks mems_allowed.
*
* Both fullzones and z_to_n[] are one-to-one with the zonelist,
* indexed by a zones offset in the zonelist zones[] array.
*
* The get_page_from_freelist() routine does two scans. During the
* first scan, we skip zones whose corresponding bit in 'fullzones'
* is set or whose corresponding node in current->mems_allowed (which
* comes from cpusets) is not set. During the second scan, we bypass
* this zonelist_cache, to ensure we look methodically at each zone.
*
* Once per second, we zero out (zap) fullzones, forcing us to
* reconsider nodes that might have regained more free memory.
* The field last_full_zap is the time we last zapped fullzones.
*
* This mechanism reduces the amount of time we waste repeatedly
* reexaming zones for free memory when they just came up low on
* memory momentarilly ago.
*
* The zonelist_cache struct members logically belong in struct
* zonelist. However, the mempolicy zonelists constructed for
* MPOL_BIND are intentionally variable length (and usually much
* shorter). A general purpose mechanism for handling structs with
* multiple variable length members is more mechanism than we want
* here. We resort to some special case hackery instead.
*
* The MPOL_BIND zonelists don't need this zonelist_cache (in good
* part because they are shorter), so we put the fixed length stuff
* at the front of the zonelist struct, ending in a variable length
* zones[], as is needed by MPOL_BIND.
*
* Then we put the optional zonelist cache on the end of the zonelist
* struct. This optional stuff is found by a 'zlcache_ptr' pointer in
* the fixed length portion at the front of the struct. This pointer
* both enables us to find the zonelist cache, and in the case of
* MPOL_BIND zonelists, (which will just set the zlcache_ptr to NULL)
* to know that the zonelist cache is not there.
*
* The end result is that struct zonelists come in two flavors:
* 1) The full, fixed length version, shown below, and
* 2) The custom zonelists for MPOL_BIND.
* The custom MPOL_BIND zonelists have a NULL zlcache_ptr and no zlcache.
*
* Even though there may be multiple CPU cores on a node modifying
* fullzones or last_full_zap in the same zonelist_cache at the same
* time, we don't lock it. This is just hint data - if it is wrong now
* and then, the allocator will still function, perhaps a bit slower.
*/
struct zonelist_cache {
unsigned short z_to_n[MAX_ZONES_PER_ZONELIST]; /* zone->nid */
DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST); /* zone full? */
unsigned long last_full_zap; /* when last zap'd (jiffies) */
};
#else
#define MAX_ZONELISTS 1
struct zonelist_cache;
#endif
/*
* This struct contains information about a zone in a zonelist. It is stored
* here to avoid dereferences into large structures and lookups of tables
*/
struct zoneref {
struct zone *zone; /* Pointer to actual zone */
int zone_idx; /* zone_idx(zoneref->zone) */
};
/*
* One allocation request operates on a zonelist. A zonelist
* is a list of zones, the first one is the 'goal' of the
* allocation, the other zones are fallback zones, in decreasing
* priority.
*
* If zlcache_ptr is not NULL, then it is just the address of zlcache,
* as explained above. If zlcache_ptr is NULL, there is no zlcache.
* *
* To speed the reading of the zonelist, the zonerefs contain the zone index
* of the entry being read. Helper functions to access information given
* a struct zoneref are
*
* zonelist_zone() - Return the struct zone * for an entry in _zonerefs
* zonelist_zone_idx() - Return the index of the zone for an entry
* zonelist_node_idx() - Return the index of the node for an entry
*/
struct zonelist {
struct zonelist_cache *zlcache_ptr; // NULL or &zlcache
struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
#ifdef CONFIG_NUMA
struct zonelist_cache zlcache; // optional ...
#endif
};
#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
struct node_active_region {
unsigned long start_pfn;
unsigned long end_pfn;
int nid;
};
#endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
#ifndef CONFIG_DISCONTIGMEM
/* The array of struct pages - for discontigmem use pgdat->lmem_map */
extern struct page *mem_map;
#endif
/*
* The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
* (mostly NUMA machines?) to denote a higher-level memory zone than the
* zone denotes.
*
* On NUMA machines, each NUMA node would have a pg_data_t to describe
* it's memory layout.
*
* Memory statistics and page replacement data structures are maintained on a
* per-zone basis.
*/
struct bootmem_data;
typedef struct pglist_data {
struct zone node_zones[MAX_NR_ZONES];
struct zonelist node_zonelists[MAX_ZONELISTS];
int nr_zones;
#ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
struct page *node_mem_map;
#ifdef CONFIG_MEMCG
struct page_cgroup *node_page_cgroup;
#endif
#endif
#ifndef CONFIG_NO_BOOTMEM
struct bootmem_data *bdata;
#endif
#ifdef CONFIG_MEMORY_HOTPLUG
/*
* Must be held any time you expect node_start_pfn, node_present_pages
* or node_spanned_pages stay constant. Holding this will also
* guarantee that any pfn_valid() stays that way.
*
* Nests above zone->lock and zone->size_seqlock.
*/
spinlock_t node_size_lock;
#endif
unsigned long node_start_pfn;
unsigned long node_present_pages; /* total number of physical pages */
unsigned long node_spanned_pages; /* total size of physical page
range, including holes */
int node_id;
nodemask_t reclaim_nodes; /* Nodes allowed to reclaim from */
wait_queue_head_t kswapd_wait;
wait_queue_head_t pfmemalloc_wait;
struct task_struct *kswapd; /* Protected by lock_memory_hotplug() */
int kswapd_max_order;
enum zone_type classzone_idx;
#ifdef CONFIG_NUMA_BALANCING
/*
* Lock serializing the per destination node AutoNUMA memory
* migration rate limiting data.
*/
spinlock_t numabalancing_migrate_lock;
/* Rate limiting time interval */
unsigned long numabalancing_migrate_next_window;
/* Number of pages migrated during the rate limiting time interval */
unsigned long numabalancing_migrate_nr_pages;
#endif
} pg_data_t;
#define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
#define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
#ifdef CONFIG_FLAT_NODE_MEM_MAP
#define pgdat_page_nr(pgdat, pagenr) ((pgdat)->node_mem_map + (pagenr))
#else
#define pgdat_page_nr(pgdat, pagenr) pfn_to_page((pgdat)->node_start_pfn + (pagenr))
#endif
#define nid_page_nr(nid, pagenr) pgdat_page_nr(NODE_DATA(nid),(pagenr))
#define node_start_pfn(nid) (NODE_DATA(nid)->node_start_pfn)
#define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))
static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)
{
return pgdat->node_start_pfn + pgdat->node_spanned_pages;
}
static inline bool pgdat_is_empty(pg_data_t *pgdat)
{
return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
}
#include <linux/memory_hotplug.h>
extern struct mutex zonelists_mutex;
void build_all_zonelists(pg_data_t *pgdat, struct zone *zone);
void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx);
bool zone_watermark_ok(struct zone *z, int order, unsigned long mark,
int classzone_idx, int alloc_flags);
bool zone_watermark_ok_safe(struct zone *z, int order, unsigned long mark,
int classzone_idx, int alloc_flags);
enum memmap_context {
MEMMAP_EARLY,
MEMMAP_HOTPLUG,
};
extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
unsigned long size,
enum memmap_context context);
extern void lruvec_init(struct lruvec *lruvec);
static inline struct zone *lruvec_zone(struct lruvec *lruvec)
{
#ifdef CONFIG_MEMCG
return lruvec->zone;
#else
return container_of(lruvec, struct zone, lruvec);
#endif
}
#ifdef CONFIG_HAVE_MEMORY_PRESENT
void memory_present(int nid, unsigned long start, unsigned long end);
#else
static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
#endif
#ifdef CONFIG_HAVE_MEMORYLESS_NODES
int local_memory_node(int node_id);
#else
static inline int local_memory_node(int node_id) { return node_id; };
#endif
#ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
#endif
/*
* zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
*/
#define zone_idx(zone) ((zone) - (zone)->zone_pgdat->node_zones)
static inline int populated_zone(struct zone *zone)
{
return (!!zone->present_pages);
}
extern int movable_zone;
static inline int zone_movable_is_highmem(void)
{
#if defined(CONFIG_HIGHMEM) && defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
return movable_zone == ZONE_HIGHMEM;
#else
return 0;
#endif
}
static inline int is_highmem_idx(enum zone_type idx)
{
#ifdef CONFIG_HIGHMEM
return (idx == ZONE_HIGHMEM ||
(idx == ZONE_MOVABLE && zone_movable_is_highmem()));
#else
return 0;
#endif
}
static inline int is_normal_idx(enum zone_type idx)
{
return (idx == ZONE_NORMAL);
}
/**
* is_highmem - helper function to quickly check if a struct zone is a
* highmem zone or not. This is an attempt to keep references
* to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
* @zone - pointer to struct zone variable
*/
static inline int is_highmem(struct zone *zone)
{
#ifdef CONFIG_HIGHMEM
int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
(zone_off == ZONE_MOVABLE * sizeof(*zone) &&
zone_movable_is_highmem());
#else
return 0;
#endif
}
static inline int is_normal(struct zone *zone)
{
return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
}
static inline int is_dma32(struct zone *zone)
{
#ifdef CONFIG_ZONE_DMA32
return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
#else
return 0;
#endif
}
static inline int is_dma(struct zone *zone)
{
#ifdef CONFIG_ZONE_DMA
return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
#else
return 0;
#endif
}
/* These two functions are used to setup the per zone pages min values */
struct ctl_table;
int min_free_kbytes_sysctl_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
extern int numa_zonelist_order_handler(struct ctl_table *, int,
void __user *, size_t *, loff_t *);
extern char numa_zonelist_order[];
#define NUMA_ZONELIST_ORDER_LEN 16 /* string buffer size */
#ifndef CONFIG_NEED_MULTIPLE_NODES
extern struct pglist_data contig_page_data;
#define NODE_DATA(nid) (&contig_page_data)
#define NODE_MEM_MAP(nid) mem_map
#else /* CONFIG_NEED_MULTIPLE_NODES */
#include <asm/mmzone.h>
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
extern struct pglist_data *first_online_pgdat(void);
extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
extern struct zone *next_zone(struct zone *zone);
/**
* for_each_online_pgdat - helper macro to iterate over all online nodes
* @pgdat - pointer to a pg_data_t variable
*/
#define for_each_online_pgdat(pgdat) \
for (pgdat = first_online_pgdat(); \
pgdat; \
pgdat = next_online_pgdat(pgdat))
/**
* for_each_zone - helper macro to iterate over all memory zones
* @zone - pointer to struct zone variable
*
* The user only needs to declare the zone variable, for_each_zone
* fills it in.
*/
#define for_each_zone(zone) \
for (zone = (first_online_pgdat())->node_zones; \
zone; \
zone = next_zone(zone))
#define for_each_populated_zone(zone) \
for (zone = (first_online_pgdat())->node_zones; \
zone; \
zone = next_zone(zone)) \
if (!populated_zone(zone)) \
; /* do nothing */ \
else
static inline struct zone *zonelist_zone(struct zoneref *zoneref)
{
return zoneref->zone;
}
static inline int zonelist_zone_idx(struct zoneref *zoneref)
{
return zoneref->zone_idx;
}
static inline int zonelist_node_idx(struct zoneref *zoneref)
{
#ifdef CONFIG_NUMA
/* zone_to_nid not available in this context */
return zoneref->zone->node;
#else
return 0;
#endif /* CONFIG_NUMA */
}
/**
* next_zones_zonelist - Returns the next zone at or below highest_zoneidx within the allowed nodemask using a cursor within a zonelist as a starting point
* @z - The cursor used as a starting point for the search
* @highest_zoneidx - The zone index of the highest zone to return
* @nodes - An optional nodemask to filter the zonelist with
* @zone - The first suitable zone found is returned via this parameter
*
* This function returns the next zone at or below a given zone index that is
* within the allowed nodemask using a cursor as the starting point for the
* search. The zoneref returned is a cursor that represents the current zone
* being examined. It should be advanced by one before calling
* next_zones_zonelist again.
*/
struct zoneref *next_zones_zonelist(struct zoneref *z,
enum zone_type highest_zoneidx,
nodemask_t *nodes,
struct zone **zone);
/**
* first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
* @zonelist - The zonelist to search for a suitable zone
* @highest_zoneidx - The zone index of the highest zone to return
* @nodes - An optional nodemask to filter the zonelist with
* @zone - The first suitable zone found is returned via this parameter
*
* This function returns the first zone at or below a given zone index that is
* within the allowed nodemask. The zoneref returned is a cursor that can be
* used to iterate the zonelist with next_zones_zonelist by advancing it by
* one before calling.
*/
static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
enum zone_type highest_zoneidx,
nodemask_t *nodes,
struct zone **zone)
{
return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
zone);
}
/**
* for_each_zone_zonelist_nodemask - helper macro to iterate over valid zones in a zonelist at or below a given zone index and within a nodemask
* @zone - The current zone in the iterator
* @z - The current pointer within zonelist->zones being iterated
* @zlist - The zonelist being iterated
* @highidx - The zone index of the highest zone to return
* @nodemask - Nodemask allowed by the allocator
*
* This iterator iterates though all zones at or below a given zone index and
* within a given nodemask
*/
#define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
for (z = first_zones_zonelist(zlist, highidx, nodemask, &zone); \
zone; \
z = next_zones_zonelist(++z, highidx, nodemask, &zone)) \
/**
* for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
* @zone - The current zone in the iterator
* @z - The current pointer within zonelist->zones being iterated
* @zlist - The zonelist being iterated
* @highidx - The zone index of the highest zone to return
*
* This iterator iterates though all zones at or below a given zone index.
*/
#define for_each_zone_zonelist(zone, z, zlist, highidx) \
for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
#ifdef CONFIG_SPARSEMEM
#include <asm/sparsemem.h>
#endif
#if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
!defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
static inline unsigned long early_pfn_to_nid(unsigned long pfn)
{
return 0;
}
#endif
#ifdef CONFIG_FLATMEM
#define pfn_to_nid(pfn) (0)
#endif
#ifdef CONFIG_SPARSEMEM
/*
* SECTION_SHIFT #bits space required to store a section #
*
* PA_SECTION_SHIFT physical address to/from section number
* PFN_SECTION_SHIFT pfn to/from section number
*/
#define PA_SECTION_SHIFT (SECTION_SIZE_BITS)
#define PFN_SECTION_SHIFT (SECTION_SIZE_BITS - PAGE_SHIFT)
#define NR_MEM_SECTIONS (1UL << SECTIONS_SHIFT)
#define PAGES_PER_SECTION (1UL << PFN_SECTION_SHIFT)
#define PAGE_SECTION_MASK (~(PAGES_PER_SECTION-1))
#define SECTION_BLOCKFLAGS_BITS \
((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
#error Allocator MAX_ORDER exceeds SECTION_SIZE
#endif
#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
#define SECTION_ALIGN_UP(pfn) (((pfn) + PAGES_PER_SECTION - 1) & PAGE_SECTION_MASK)
#define SECTION_ALIGN_DOWN(pfn) ((pfn) & PAGE_SECTION_MASK)
struct page;
struct page_cgroup;
struct mem_section {
/*
* This is, logically, a pointer to an array of struct
* pages. However, it is stored with some other magic.
* (see sparse.c::sparse_init_one_section())
*
* Additionally during early boot we encode node id of
* the location of the section here to guide allocation.
* (see sparse.c::memory_present())
*
* Making it a UL at least makes someone do a cast
* before using it wrong.
*/
unsigned long section_mem_map;
/* See declaration of similar field in struct zone */
unsigned long *pageblock_flags;
#ifdef CONFIG_MEMCG
/*
* If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use
* section. (see memcontrol.h/page_cgroup.h about this.)
*/
struct page_cgroup *page_cgroup;
unsigned long pad;
#endif
};
#ifdef CONFIG_SPARSEMEM_EXTREME
#define SECTIONS_PER_ROOT (PAGE_SIZE / sizeof (struct mem_section))
#else
#define SECTIONS_PER_ROOT 1
#endif
#define SECTION_NR_TO_ROOT(sec) ((sec) / SECTIONS_PER_ROOT)
#define NR_SECTION_ROOTS DIV_ROUND_UP(NR_MEM_SECTIONS, SECTIONS_PER_ROOT)
#define SECTION_ROOT_MASK (SECTIONS_PER_ROOT - 1)
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
#else
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
#endif
static inline struct mem_section *__nr_to_section(unsigned long nr)
{
if (!mem_section[SECTION_NR_TO_ROOT(nr)])
return NULL;
return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
}
extern int __section_nr(struct mem_section* ms);
extern unsigned long usemap_size(void);
/*
* We use the lower bits of the mem_map pointer to store
* a little bit of information. There should be at least
* 3 bits here due to 32-bit alignment.
*/
#define SECTION_MARKED_PRESENT (1UL<<0)
#define SECTION_HAS_MEM_MAP (1UL<<1)
#define SECTION_MAP_LAST_BIT (1UL<<2)
#define SECTION_MAP_MASK (~(SECTION_MAP_LAST_BIT-1))
#define SECTION_NID_SHIFT 2
static inline struct page *__section_mem_map_addr(struct mem_section *section)
{
unsigned long map = section->section_mem_map;
map &= SECTION_MAP_MASK;
return (struct page *)map;
}
static inline int present_section(struct mem_section *section)
{
return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
}
static inline int present_section_nr(unsigned long nr)
{
return present_section(__nr_to_section(nr));
}
static inline int valid_section(struct mem_section *section)
{
return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
}
static inline int valid_section_nr(unsigned long nr)
{
return valid_section(__nr_to_section(nr));
}
static inline struct mem_section *__pfn_to_section(unsigned long pfn)
{
return __nr_to_section(pfn_to_section_nr(pfn));
}
#ifndef CONFIG_HAVE_ARCH_PFN_VALID
static inline int pfn_valid(unsigned long pfn)
{
if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
return 0;
return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
}
#endif
static inline int pfn_present(unsigned long pfn)
{
if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
return 0;
return present_section(__nr_to_section(pfn_to_section_nr(pfn)));
}
/*
* These are _only_ used during initialisation, therefore they
* can use __initdata ... They could have names to indicate
* this restriction.
*/
#ifdef CONFIG_NUMA
#define pfn_to_nid(pfn) \
({ \
unsigned long __pfn_to_nid_pfn = (pfn); \
page_to_nid(pfn_to_page(__pfn_to_nid_pfn)); \
})
#else
#define pfn_to_nid(pfn) (0)
#endif
#ifndef early_pfn_valid
#define early_pfn_valid(pfn) pfn_valid(pfn)
#endif
void sparse_init(void);
#else
#define sparse_init() do {} while (0)
#define sparse_index_init(_sec, _nid) do {} while (0)
#endif /* CONFIG_SPARSEMEM */
#ifdef CONFIG_NODES_SPAN_OTHER_NODES
bool early_pfn_in_nid(unsigned long pfn, int nid);
#else
#define early_pfn_in_nid(pfn, nid) (1)
#endif
#ifndef early_pfn_valid
#define early_pfn_valid(pfn) (1)
#endif
void memory_present(int nid, unsigned long start, unsigned long end);
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
/*
* If it is possible to have holes within a MAX_ORDER_NR_PAGES, then we
* need to check pfn validility within that MAX_ORDER_NR_PAGES block.
* pfn_valid_within() should be used in this case; we optimise this away
* when we have no holes within a MAX_ORDER_NR_PAGES block.
*/
#ifdef CONFIG_HOLES_IN_ZONE
#define pfn_valid_within(pfn) pfn_valid(pfn)
#else
#define pfn_valid_within(pfn) (1)
#endif
#ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL
/*
* pfn_valid() is meant to be able to tell if a given PFN has valid memmap
* associated with it or not. In FLATMEM, it is expected that holes always
* have valid memmap as long as there is valid PFNs either side of the hole.
* In SPARSEMEM, it is assumed that a valid section has a memmap for the
* entire section.
*
* However, an ARM, and maybe other embedded architectures in the future
* free memmap backing holes to save memory on the assumption the memmap is
* never used. The page_zone linkages are then broken even though pfn_valid()
* returns true. A walker of the full memmap must then do this additional
* check to ensure the memmap they are looking at is sane by making sure
* the zone and PFN linkages are still valid. This is expensive, but walkers
* of the full memmap are extremely rare.
*/
int memmap_valid_within(unsigned long pfn,
struct page *page, struct zone *zone);
#else
static inline int memmap_valid_within(unsigned long pfn,
struct page *page, struct zone *zone)
{
return 1;
}
#endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */
#endif /* !__GENERATING_BOUNDS.H */
#endif /* !__ASSEMBLY__ */
#endif /* _LINUX_MMZONE_H */
| gpl-2.0 |
Sananes/ScruplesWoo | wp-content/plugins/woocommerce-skrill-moneybookers-gateway/src/vendor/mockery/mockery/docs/14-PRESERVING-PASS-BY-REFERENCE-PARAMETER-BEHAVIOUR.md | 2851 | # Preserving Pass-By-Reference Method Parameter Behaviour
PHP Class method may accept parameters by reference. In this case, changes made
to the parameter (a reference to the original variable passed to the method) are
reflected in the original variable. A simple example:
```PHP
class Foo {
public function bar(&$a) {
$a++;
}
}
$baz = 1;
$foo = new Foo;
$foo->bar($baz);
echo $baz; // will echo the integer 2
```
In the example above, the variable $baz is passed by reference to `Foo::bar()`
(notice the `&` symbol in front of the parameter?).
Any change `bar()` makes to the parameter reference is reflected in the original
variable, `$baz`.
Mockery 0.7+ handles references correctly for all methods where it can analyse the
parameter (using `Reflection`) to see if it is passed by reference. To mock how a
reference is manipulated by the class method, you can use a closure argument
matcher to manipulate it, i.e. `\Mockery::on()` - see the [Argument
Validation](07-ARGUMENT-VALIDATION.md) chapter.
There is an exception for internal PHP classes where Mockery cannot analyse
method parameters using `Reflection` (a limitation in PHP). To work around this,
you can explicitly declare method parameters for an internal class using
`/Mockery/Configuration::setInternalClassMethodParamMap()`.
Here's an example using `MongoCollection::insert()`. `MongoCollection` is an internal
class offered by the mongo extension from PECL. Its `insert()` method accepts an array
of data as the first parameter, and an optional options array as the second
parameter. The original data array is updated (i.e. when a `insert()` pass-by-reference
parameter) to include a new `_id` field. We can mock this behaviour using
a configured parameter map (to tell Mockery to expect a pass by reference parameter)
and a Closure attached to the expected method parameter to be updated.
Here's a PHPUnit unit test verifying that this pass-by-reference behaviour is preserved:
```PHP
public function testCanOverrideExpectedParametersOfInternalPHPClassesToPreserveRefs()
{
\Mockery::getConfiguration()->setInternalClassMethodParamMap(
'MongoCollection',
'insert',
array('&$data', '$options = array()')
);
$m = \Mockery::mock('MongoCollection');
$m->shouldReceive('insert')->with(
\Mockery::on(function(&$data) {
if (!is_array($data)) return false;
$data['_id'] = 123;
return true;
}),
\Mockery::any()
);
$data = array('a'=>1,'b'=>2);
$m->insert($data);
$this->assertTrue(isset($data['_id']));
$this->assertEquals(123, $data['_id']);
\Mockery::resetContainer();
}
```
**[← Previous](13-INSTANCE-MOCKING.md) | [Contents](../README.md#documentation) | [Next →](15-MOCKING-DEMETER-CHAINS-AND-FLUENT-INTERFACES.md)**
| gpl-2.0 |
jeremymcrhat/Nexus_5X_kernel | drivers/iio/light/max44000.c | 17148 | /*
* MAX44000 Ambient and Infrared Proximity Sensor
*
* Copyright (c) 2016, Intel Corporation.
*
* This file is subject to the terms and conditions of version 2 of
* the GNU General Public License. See the file COPYING in the main
* directory of this archive for more details.
*
* Data sheet: https://datasheets.maximintegrated.com/en/ds/MAX44000.pdf
*
* 7-bit I2C slave address 0x4a
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/regmap.h>
#include <linux/util_macros.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/acpi.h>
#define MAX44000_DRV_NAME "max44000"
/* Registers in datasheet order */
#define MAX44000_REG_STATUS 0x00
#define MAX44000_REG_CFG_MAIN 0x01
#define MAX44000_REG_CFG_RX 0x02
#define MAX44000_REG_CFG_TX 0x03
#define MAX44000_REG_ALS_DATA_HI 0x04
#define MAX44000_REG_ALS_DATA_LO 0x05
#define MAX44000_REG_PRX_DATA 0x16
#define MAX44000_REG_ALS_UPTHR_HI 0x06
#define MAX44000_REG_ALS_UPTHR_LO 0x07
#define MAX44000_REG_ALS_LOTHR_HI 0x08
#define MAX44000_REG_ALS_LOTHR_LO 0x09
#define MAX44000_REG_PST 0x0a
#define MAX44000_REG_PRX_IND 0x0b
#define MAX44000_REG_PRX_THR 0x0c
#define MAX44000_REG_TRIM_GAIN_GREEN 0x0f
#define MAX44000_REG_TRIM_GAIN_IR 0x10
/* REG_CFG bits */
#define MAX44000_CFG_ALSINTE 0x01
#define MAX44000_CFG_PRXINTE 0x02
#define MAX44000_CFG_MASK 0x1c
#define MAX44000_CFG_MODE_SHUTDOWN 0x00
#define MAX44000_CFG_MODE_ALS_GIR 0x04
#define MAX44000_CFG_MODE_ALS_G 0x08
#define MAX44000_CFG_MODE_ALS_IR 0x0c
#define MAX44000_CFG_MODE_ALS_PRX 0x10
#define MAX44000_CFG_MODE_PRX 0x14
#define MAX44000_CFG_TRIM 0x20
/*
* Upper 4 bits are not documented but start as 1 on powerup
* Setting them to 0 causes proximity to misbehave so set them to 1
*/
#define MAX44000_REG_CFG_RX_DEFAULT 0xf0
/* REG_RX bits */
#define MAX44000_CFG_RX_ALSTIM_MASK 0x0c
#define MAX44000_CFG_RX_ALSTIM_SHIFT 2
#define MAX44000_CFG_RX_ALSPGA_MASK 0x03
#define MAX44000_CFG_RX_ALSPGA_SHIFT 0
/* REG_TX bits */
#define MAX44000_LED_CURRENT_MASK 0xf
#define MAX44000_LED_CURRENT_MAX 11
#define MAX44000_LED_CURRENT_DEFAULT 6
#define MAX44000_ALSDATA_OVERFLOW 0x4000
struct max44000_data {
struct mutex lock;
struct regmap *regmap;
};
/* Default scale is set to the minimum of 0.03125 or 1 / (1 << 5) lux */
#define MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2 5
/* Scale can be multiplied by up to 128x via ALSPGA for measurement gain */
static const int max44000_alspga_shift[] = {0, 2, 4, 7};
#define MAX44000_ALSPGA_MAX_SHIFT 7
/*
* Scale can be multiplied by up to 64x via ALSTIM because of lost resolution
*
* This scaling factor is hidden from userspace and instead accounted for when
* reading raw values from the device.
*
* This makes it possible to cleanly expose ALSPGA as IIO_CHAN_INFO_SCALE and
* ALSTIM as IIO_CHAN_INFO_INT_TIME without the values affecting each other.
*
* Handling this internally is also required for buffer support because the
* channel's scan_type can't be modified dynamically.
*/
static const int max44000_alstim_shift[] = {0, 2, 4, 6};
#define MAX44000_ALSTIM_SHIFT(alstim) (2 * (alstim))
/* Available integration times with pretty manual alignment: */
static const int max44000_int_time_avail_ns_array[] = {
100000000,
25000000,
6250000,
1562500,
};
static const char max44000_int_time_avail_str[] =
"0.100 "
"0.025 "
"0.00625 "
"0.001625";
/* Available scales (internal to ulux) with pretty manual alignment: */
static const int max44000_scale_avail_ulux_array[] = {
31250,
125000,
500000,
4000000,
};
static const char max44000_scale_avail_str[] =
"0.03125 "
"0.125 "
"0.5 "
"4";
#define MAX44000_SCAN_INDEX_ALS 0
#define MAX44000_SCAN_INDEX_PRX 1
static const struct iio_chan_spec max44000_channels[] = {
{
.type = IIO_LIGHT,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_INT_TIME),
.scan_index = MAX44000_SCAN_INDEX_ALS,
.scan_type = {
.sign = 'u',
.realbits = 14,
.storagebits = 16,
}
},
{
.type = IIO_PROXIMITY,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
.scan_index = MAX44000_SCAN_INDEX_PRX,
.scan_type = {
.sign = 'u',
.realbits = 8,
.storagebits = 16,
}
},
IIO_CHAN_SOFT_TIMESTAMP(2),
{
.type = IIO_CURRENT,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE),
.extend_name = "led",
.output = 1,
.scan_index = -1,
},
};
static int max44000_read_alstim(struct max44000_data *data)
{
unsigned int val;
int ret;
ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
if (ret < 0)
return ret;
return (val & MAX44000_CFG_RX_ALSTIM_MASK) >> MAX44000_CFG_RX_ALSTIM_SHIFT;
}
static int max44000_write_alstim(struct max44000_data *data, int val)
{
return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
MAX44000_CFG_RX_ALSTIM_MASK,
val << MAX44000_CFG_RX_ALSTIM_SHIFT);
}
static int max44000_read_alspga(struct max44000_data *data)
{
unsigned int val;
int ret;
ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
if (ret < 0)
return ret;
return (val & MAX44000_CFG_RX_ALSPGA_MASK) >> MAX44000_CFG_RX_ALSPGA_SHIFT;
}
static int max44000_write_alspga(struct max44000_data *data, int val)
{
return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
MAX44000_CFG_RX_ALSPGA_MASK,
val << MAX44000_CFG_RX_ALSPGA_SHIFT);
}
static int max44000_read_alsval(struct max44000_data *data)
{
u16 regval;
int alstim, ret;
ret = regmap_bulk_read(data->regmap, MAX44000_REG_ALS_DATA_HI,
®val, sizeof(regval));
if (ret < 0)
return ret;
alstim = ret = max44000_read_alstim(data);
if (ret < 0)
return ret;
regval = be16_to_cpu(regval);
/*
* Overflow is explained on datasheet page 17.
*
* It's a warning that either the G or IR channel has become saturated
* and that the value in the register is likely incorrect.
*
* The recommendation is to change the scale (ALSPGA).
* The driver just returns the max representable value.
*/
if (regval & MAX44000_ALSDATA_OVERFLOW)
return 0x3FFF;
return regval << MAX44000_ALSTIM_SHIFT(alstim);
}
static int max44000_write_led_current_raw(struct max44000_data *data, int val)
{
/* Maybe we should clamp the value instead? */
if (val < 0 || val > MAX44000_LED_CURRENT_MAX)
return -ERANGE;
if (val >= 8)
val += 4;
return regmap_write_bits(data->regmap, MAX44000_REG_CFG_TX,
MAX44000_LED_CURRENT_MASK, val);
}
static int max44000_read_led_current_raw(struct max44000_data *data)
{
unsigned int regval;
int ret;
ret = regmap_read(data->regmap, MAX44000_REG_CFG_TX, ®val);
if (ret < 0)
return ret;
regval &= MAX44000_LED_CURRENT_MASK;
if (regval >= 8)
regval -= 4;
return regval;
}
static int max44000_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct max44000_data *data = iio_priv(indio_dev);
int alstim, alspga;
unsigned int regval;
int ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
switch (chan->type) {
case IIO_LIGHT:
mutex_lock(&data->lock);
ret = max44000_read_alsval(data);
mutex_unlock(&data->lock);
if (ret < 0)
return ret;
*val = ret;
return IIO_VAL_INT;
case IIO_PROXIMITY:
mutex_lock(&data->lock);
ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, ®val);
mutex_unlock(&data->lock);
if (ret < 0)
return ret;
*val = regval;
return IIO_VAL_INT;
case IIO_CURRENT:
mutex_lock(&data->lock);
ret = max44000_read_led_current_raw(data);
mutex_unlock(&data->lock);
if (ret < 0)
return ret;
*val = ret;
return IIO_VAL_INT;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SCALE:
switch (chan->type) {
case IIO_CURRENT:
/* Output register is in 10s of miliamps */
*val = 10;
return IIO_VAL_INT;
case IIO_LIGHT:
mutex_lock(&data->lock);
alspga = ret = max44000_read_alspga(data);
mutex_unlock(&data->lock);
if (ret < 0)
return ret;
/* Avoid negative shifts */
*val = (1 << MAX44000_ALSPGA_MAX_SHIFT);
*val2 = MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2
+ MAX44000_ALSPGA_MAX_SHIFT
- max44000_alspga_shift[alspga];
return IIO_VAL_FRACTIONAL_LOG2;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_INT_TIME:
mutex_lock(&data->lock);
alstim = ret = max44000_read_alstim(data);
mutex_unlock(&data->lock);
if (ret < 0)
return ret;
*val = 0;
*val2 = max44000_int_time_avail_ns_array[alstim];
return IIO_VAL_INT_PLUS_NANO;
default:
return -EINVAL;
}
}
static int max44000_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct max44000_data *data = iio_priv(indio_dev);
int ret;
if (mask == IIO_CHAN_INFO_RAW && chan->type == IIO_CURRENT) {
mutex_lock(&data->lock);
ret = max44000_write_led_current_raw(data, val);
mutex_unlock(&data->lock);
return ret;
} else if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT) {
s64 valns = val * NSEC_PER_SEC + val2;
int alstim = find_closest_descending(valns,
max44000_int_time_avail_ns_array,
ARRAY_SIZE(max44000_int_time_avail_ns_array));
mutex_lock(&data->lock);
ret = max44000_write_alstim(data, alstim);
mutex_unlock(&data->lock);
return ret;
} else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT) {
s64 valus = val * USEC_PER_SEC + val2;
int alspga = find_closest(valus,
max44000_scale_avail_ulux_array,
ARRAY_SIZE(max44000_scale_avail_ulux_array));
mutex_lock(&data->lock);
ret = max44000_write_alspga(data, alspga);
mutex_unlock(&data->lock);
return ret;
}
return -EINVAL;
}
static int max44000_write_raw_get_fmt(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
long mask)
{
if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT)
return IIO_VAL_INT_PLUS_NANO;
else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT)
return IIO_VAL_INT_PLUS_MICRO;
else
return IIO_VAL_INT;
}
static IIO_CONST_ATTR(illuminance_integration_time_available, max44000_int_time_avail_str);
static IIO_CONST_ATTR(illuminance_scale_available, max44000_scale_avail_str);
static struct attribute *max44000_attributes[] = {
&iio_const_attr_illuminance_integration_time_available.dev_attr.attr,
&iio_const_attr_illuminance_scale_available.dev_attr.attr,
NULL
};
static const struct attribute_group max44000_attribute_group = {
.attrs = max44000_attributes,
};
static const struct iio_info max44000_info = {
.driver_module = THIS_MODULE,
.read_raw = max44000_read_raw,
.write_raw = max44000_write_raw,
.write_raw_get_fmt = max44000_write_raw_get_fmt,
.attrs = &max44000_attribute_group,
};
static bool max44000_readable_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case MAX44000_REG_STATUS:
case MAX44000_REG_CFG_MAIN:
case MAX44000_REG_CFG_RX:
case MAX44000_REG_CFG_TX:
case MAX44000_REG_ALS_DATA_HI:
case MAX44000_REG_ALS_DATA_LO:
case MAX44000_REG_PRX_DATA:
case MAX44000_REG_ALS_UPTHR_HI:
case MAX44000_REG_ALS_UPTHR_LO:
case MAX44000_REG_ALS_LOTHR_HI:
case MAX44000_REG_ALS_LOTHR_LO:
case MAX44000_REG_PST:
case MAX44000_REG_PRX_IND:
case MAX44000_REG_PRX_THR:
case MAX44000_REG_TRIM_GAIN_GREEN:
case MAX44000_REG_TRIM_GAIN_IR:
return true;
default:
return false;
}
}
static bool max44000_writeable_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case MAX44000_REG_CFG_MAIN:
case MAX44000_REG_CFG_RX:
case MAX44000_REG_CFG_TX:
case MAX44000_REG_ALS_UPTHR_HI:
case MAX44000_REG_ALS_UPTHR_LO:
case MAX44000_REG_ALS_LOTHR_HI:
case MAX44000_REG_ALS_LOTHR_LO:
case MAX44000_REG_PST:
case MAX44000_REG_PRX_IND:
case MAX44000_REG_PRX_THR:
case MAX44000_REG_TRIM_GAIN_GREEN:
case MAX44000_REG_TRIM_GAIN_IR:
return true;
default:
return false;
}
}
static bool max44000_volatile_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case MAX44000_REG_STATUS:
case MAX44000_REG_ALS_DATA_HI:
case MAX44000_REG_ALS_DATA_LO:
case MAX44000_REG_PRX_DATA:
return true;
default:
return false;
}
}
static bool max44000_precious_reg(struct device *dev, unsigned int reg)
{
return reg == MAX44000_REG_STATUS;
}
static const struct regmap_config max44000_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = MAX44000_REG_PRX_DATA,
.readable_reg = max44000_readable_reg,
.writeable_reg = max44000_writeable_reg,
.volatile_reg = max44000_volatile_reg,
.precious_reg = max44000_precious_reg,
.use_single_rw = 1,
.cache_type = REGCACHE_RBTREE,
};
static irqreturn_t max44000_trigger_handler(int irq, void *p)
{
struct iio_poll_func *pf = p;
struct iio_dev *indio_dev = pf->indio_dev;
struct max44000_data *data = iio_priv(indio_dev);
u16 buf[8]; /* 2x u16 + padding + 8 bytes timestamp */
int index = 0;
unsigned int regval;
int ret;
mutex_lock(&data->lock);
if (test_bit(MAX44000_SCAN_INDEX_ALS, indio_dev->active_scan_mask)) {
ret = max44000_read_alsval(data);
if (ret < 0)
goto out_unlock;
buf[index++] = ret;
}
if (test_bit(MAX44000_SCAN_INDEX_PRX, indio_dev->active_scan_mask)) {
ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, ®val);
if (ret < 0)
goto out_unlock;
buf[index] = regval;
}
mutex_unlock(&data->lock);
iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
out_unlock:
mutex_unlock(&data->lock);
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
static int max44000_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct max44000_data *data;
struct iio_dev *indio_dev;
int ret, reg;
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
if (!indio_dev)
return -ENOMEM;
data = iio_priv(indio_dev);
data->regmap = devm_regmap_init_i2c(client, &max44000_regmap_config);
if (IS_ERR(data->regmap)) {
dev_err(&client->dev, "regmap_init failed!\n");
return PTR_ERR(data->regmap);
}
i2c_set_clientdata(client, indio_dev);
mutex_init(&data->lock);
indio_dev->dev.parent = &client->dev;
indio_dev->info = &max44000_info;
indio_dev->name = MAX44000_DRV_NAME;
indio_dev->channels = max44000_channels;
indio_dev->num_channels = ARRAY_SIZE(max44000_channels);
/*
* The device doesn't have a reset function so we just clear some
* important bits at probe time to ensure sane operation.
*
* Since we don't support interrupts/events the threshold values are
* not important. We also don't touch trim values.
*/
/* Reset ALS scaling bits */
ret = regmap_write(data->regmap, MAX44000_REG_CFG_RX,
MAX44000_REG_CFG_RX_DEFAULT);
if (ret < 0) {
dev_err(&client->dev, "failed to write default CFG_RX: %d\n",
ret);
return ret;
}
/*
* By default the LED pulse used for the proximity sensor is disabled.
* Set a middle value so that we get some sort of valid data by default.
*/
ret = max44000_write_led_current_raw(data, MAX44000_LED_CURRENT_DEFAULT);
if (ret < 0) {
dev_err(&client->dev, "failed to write init config: %d\n", ret);
return ret;
}
/* Reset CFG bits to ALS_PRX mode which allows easy reading of both values. */
reg = MAX44000_CFG_TRIM | MAX44000_CFG_MODE_ALS_PRX;
ret = regmap_write(data->regmap, MAX44000_REG_CFG_MAIN, reg);
if (ret < 0) {
dev_err(&client->dev, "failed to write init config: %d\n", ret);
return ret;
}
/* Read status at least once to clear any stale interrupt bits. */
ret = regmap_read(data->regmap, MAX44000_REG_STATUS, ®);
if (ret < 0) {
dev_err(&client->dev, "failed to read init status: %d\n", ret);
return ret;
}
ret = iio_triggered_buffer_setup(indio_dev, NULL, max44000_trigger_handler, NULL);
if (ret < 0) {
dev_err(&client->dev, "iio triggered buffer setup failed\n");
return ret;
}
return iio_device_register(indio_dev);
}
static int max44000_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
iio_device_unregister(indio_dev);
iio_triggered_buffer_cleanup(indio_dev);
return 0;
}
static const struct i2c_device_id max44000_id[] = {
{"max44000", 0},
{ }
};
MODULE_DEVICE_TABLE(i2c, max44000_id);
#ifdef CONFIG_ACPI
static const struct acpi_device_id max44000_acpi_match[] = {
{"MAX44000", 0},
{ }
};
MODULE_DEVICE_TABLE(acpi, max44000_acpi_match);
#endif
static struct i2c_driver max44000_driver = {
.driver = {
.name = MAX44000_DRV_NAME,
.acpi_match_table = ACPI_PTR(max44000_acpi_match),
},
.probe = max44000_probe,
.remove = max44000_remove,
.id_table = max44000_id,
};
module_i2c_driver(max44000_driver);
MODULE_AUTHOR("Crestez Dan Leonard <[email protected]>");
MODULE_DESCRIPTION("MAX44000 Ambient and Infrared Proximity Sensor");
MODULE_LICENSE("GPL v2");
| gpl-2.0 |
mericon/Xp_Kernel_LGH850 | virt/drivers/char/diag/diag_masks.c | 56123 | /* Copyright (c) 2008-2015, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/diagchar.h>
#include <linux/kmemleak.h>
#include <linux/workqueue.h>
#include <linux/uaccess.h>
#include "diagchar.h"
#include "diagfwd_cntl.h"
#include "diag_masks.h"
#include "diagfwd_peripheral.h"
#include "diag_ipc_logging.h"
#define ALL_EQUIP_ID 100
#define ALL_SSID -1
#define DIAG_SET_FEATURE_MASK(x) (feature_bytes[(x)/8] |= (1 << (x & 0x7)))
#define diag_check_update(x) \
(!info || (info && (info->peripheral_mask & MD_PERIPHERAL_MASK(x)))) \
struct diag_mask_info msg_mask;
struct diag_mask_info msg_bt_mask;
struct diag_mask_info log_mask;
struct diag_mask_info event_mask;
static const struct diag_ssid_range_t msg_mask_tbl[] = {
{ .ssid_first = MSG_SSID_0, .ssid_last = MSG_SSID_0_LAST },
{ .ssid_first = MSG_SSID_1, .ssid_last = MSG_SSID_1_LAST },
{ .ssid_first = MSG_SSID_2, .ssid_last = MSG_SSID_2_LAST },
{ .ssid_first = MSG_SSID_3, .ssid_last = MSG_SSID_3_LAST },
{ .ssid_first = MSG_SSID_4, .ssid_last = MSG_SSID_4_LAST },
{ .ssid_first = MSG_SSID_5, .ssid_last = MSG_SSID_5_LAST },
{ .ssid_first = MSG_SSID_6, .ssid_last = MSG_SSID_6_LAST },
{ .ssid_first = MSG_SSID_7, .ssid_last = MSG_SSID_7_LAST },
{ .ssid_first = MSG_SSID_8, .ssid_last = MSG_SSID_8_LAST },
{ .ssid_first = MSG_SSID_9, .ssid_last = MSG_SSID_9_LAST },
{ .ssid_first = MSG_SSID_10, .ssid_last = MSG_SSID_10_LAST },
{ .ssid_first = MSG_SSID_11, .ssid_last = MSG_SSID_11_LAST },
{ .ssid_first = MSG_SSID_12, .ssid_last = MSG_SSID_12_LAST },
{ .ssid_first = MSG_SSID_13, .ssid_last = MSG_SSID_13_LAST },
{ .ssid_first = MSG_SSID_14, .ssid_last = MSG_SSID_14_LAST },
{ .ssid_first = MSG_SSID_15, .ssid_last = MSG_SSID_15_LAST },
{ .ssid_first = MSG_SSID_16, .ssid_last = MSG_SSID_16_LAST },
{ .ssid_first = MSG_SSID_17, .ssid_last = MSG_SSID_17_LAST },
{ .ssid_first = MSG_SSID_18, .ssid_last = MSG_SSID_18_LAST },
{ .ssid_first = MSG_SSID_19, .ssid_last = MSG_SSID_19_LAST },
{ .ssid_first = MSG_SSID_20, .ssid_last = MSG_SSID_20_LAST },
{ .ssid_first = MSG_SSID_21, .ssid_last = MSG_SSID_21_LAST },
{ .ssid_first = MSG_SSID_22, .ssid_last = MSG_SSID_22_LAST },
{ .ssid_first = MSG_SSID_23, .ssid_last = MSG_SSID_23_LAST },
{ .ssid_first = MSG_SSID_24, .ssid_last = MSG_SSID_24_LAST }
};
static int diag_apps_responds(void)
{
/*
* Apps processor should respond to mask commands only if the
* Modem channel is up, the feature mask is received from Modem
* and if Modem supports Mask Centralization.
*/
if (!chk_apps_only())
return 0;
if (driver->diagfwd_cntl[PERIPHERAL_MODEM] &&
driver->diagfwd_cntl[PERIPHERAL_MODEM]->ch_open &&
driver->feature[PERIPHERAL_MODEM].rcvd_feature_mask) {
if (driver->feature[PERIPHERAL_MODEM].mask_centralization)
return 1;
return 0;
}
return 1;
}
static void diag_send_log_mask_update(uint8_t peripheral, int equip_id)
{
int i;
int err = 0;
int send_once = 0;
int header_len = sizeof(struct diag_ctrl_log_mask);
uint8_t *buf = NULL;
uint8_t *temp = NULL;
uint32_t mask_size = 0;
struct diag_ctrl_log_mask ctrl_pkt;
struct diag_mask_info *mask_info = NULL;
struct diag_log_mask_t *mask = NULL;
if (peripheral >= NUM_PERIPHERALS)
return;
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
pr_debug("diag: In %s, control channel is not open, p: %d\n",
__func__, peripheral);
return;
}
if (driver->md_session_mask != 0 &&
driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral))
mask_info = driver->md_session_map[peripheral]->log_mask;
else
mask_info = &log_mask;
if (!mask_info)
return;
mask = (struct diag_log_mask_t *)mask_info->ptr;
buf = mask_info->update_buf;
switch (mask_info->status) {
case DIAG_CTRL_MASK_ALL_DISABLED:
ctrl_pkt.equip_id = 0;
ctrl_pkt.num_items = 0;
ctrl_pkt.log_mask_size = 0;
send_once = 1;
break;
case DIAG_CTRL_MASK_ALL_ENABLED:
ctrl_pkt.equip_id = 0;
ctrl_pkt.num_items = 0;
ctrl_pkt.log_mask_size = 0;
send_once = 1;
break;
case DIAG_CTRL_MASK_VALID:
send_once = 0;
break;
default:
pr_debug("diag: In %s, invalid log_mask status\n", __func__);
return;
}
mutex_lock(&mask_info->lock);
for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
if (equip_id != i && equip_id != ALL_EQUIP_ID)
continue;
mutex_lock(&mask->lock);
ctrl_pkt.cmd_type = DIAG_CTRL_MSG_LOG_MASK;
ctrl_pkt.stream_id = 1;
ctrl_pkt.status = mask_info->status;
if (mask_info->status == DIAG_CTRL_MASK_VALID) {
mask_size = LOG_ITEMS_TO_SIZE(mask->num_items_tools);
ctrl_pkt.equip_id = i;
ctrl_pkt.num_items = mask->num_items_tools;
ctrl_pkt.log_mask_size = mask_size;
}
ctrl_pkt.data_len = LOG_MASK_CTRL_HEADER_LEN + mask_size;
if (header_len + mask_size > mask_info->update_buf_len) {
temp = krealloc(buf, header_len + mask_size,
GFP_KERNEL);
if (!temp) {
pr_err_ratelimited("diag: Unable to realloc log update buffer, new size: %d, equip_id: %d\n",
header_len + mask_size, equip_id);
mutex_unlock(&mask->lock);
break;
}
mask_info->update_buf = temp;
mask_info->update_buf_len = header_len + mask_size;
}
memcpy(buf, &ctrl_pkt, header_len);
if (mask_size > 0)
memcpy(buf + header_len, mask->ptr, mask_size);
mutex_unlock(&mask->lock);
DIAG_LOG(DIAG_DEBUG_MASKS,
"sending ctrl pkt to %d, e %d num_items %d size %d\n",
peripheral, i, ctrl_pkt.num_items,
ctrl_pkt.log_mask_size);
err = diagfwd_write(peripheral, TYPE_CNTL,
buf, header_len + mask_size);
if (err && err != -ENODEV)
pr_err_ratelimited("diag: Unable to send log masks to peripheral %d, equip_id: %d, err: %d\n",
peripheral, i, err);
if (send_once || equip_id != ALL_EQUIP_ID)
break;
}
mutex_unlock(&mask_info->lock);
}
static void diag_send_event_mask_update(uint8_t peripheral)
{
uint8_t *buf = NULL;
uint8_t *temp = NULL;
struct diag_ctrl_event_mask header;
struct diag_mask_info *mask_info = NULL;
int num_bytes = EVENT_COUNT_TO_BYTES(driver->last_event_id);
int write_len = 0;
int err = 0;
int temp_len = 0;
if (num_bytes <= 0 || num_bytes > driver->event_mask_size) {
pr_debug("diag: In %s, invalid event mask length %d\n",
__func__, num_bytes);
return;
}
if (peripheral >= NUM_PERIPHERALS)
return;
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
pr_debug("diag: In %s, control channel is not open, p: %d\n",
__func__, peripheral);
return;
}
if (driver->md_session_mask != 0 &&
(driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral)))
mask_info = driver->md_session_map[peripheral]->event_mask;
else
mask_info = &event_mask;
if (!mask_info)
return;
buf = mask_info->update_buf;
mutex_lock(&mask_info->lock);
header.cmd_type = DIAG_CTRL_MSG_EVENT_MASK;
header.stream_id = 1;
header.status = mask_info->status;
switch (mask_info->status) {
case DIAG_CTRL_MASK_ALL_DISABLED:
header.event_config = 0;
header.event_mask_size = 0;
break;
case DIAG_CTRL_MASK_ALL_ENABLED:
header.event_config = 1;
header.event_mask_size = 0;
break;
case DIAG_CTRL_MASK_VALID:
header.event_config = 1;
header.event_mask_size = num_bytes;
if (num_bytes + sizeof(header) > mask_info->update_buf_len) {
temp_len = num_bytes + sizeof(header);
temp = krealloc(buf, temp_len, GFP_KERNEL);
if (!temp) {
pr_err("diag: Unable to realloc event mask update buffer\n");
goto err;
} else {
mask_info->update_buf = temp;
mask_info->update_buf_len = temp_len;
}
}
memcpy(buf + sizeof(header), mask_info->ptr, num_bytes);
write_len += num_bytes;
break;
default:
pr_debug("diag: In %s, invalid status %d\n", __func__,
mask_info->status);
goto err;
}
header.data_len = EVENT_MASK_CTRL_HEADER_LEN + header.event_mask_size;
memcpy(buf, &header, sizeof(header));
write_len += sizeof(header);
err = diagfwd_write(peripheral, TYPE_CNTL, buf, write_len);
if (err && err != -ENODEV)
pr_err_ratelimited("diag: Unable to send event masks to peripheral %d\n",
peripheral);
err:
mutex_unlock(&mask_info->lock);
}
static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last)
{
int i;
int err = 0;
int header_len = sizeof(struct diag_ctrl_msg_mask);
int temp_len = 0;
uint8_t *buf = NULL;
uint8_t *temp = NULL;
uint32_t mask_size = 0;
struct diag_mask_info *mask_info = NULL;
struct diag_msg_mask_t *mask = NULL;
struct diag_ctrl_msg_mask header;
if (peripheral >= NUM_PERIPHERALS)
return;
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
pr_debug("diag: In %s, control channel is not open, p: %d\n",
__func__, peripheral);
return;
}
if (driver->md_session_mask != 0 &&
(driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral)))
mask_info = driver->md_session_map[peripheral]->msg_mask;
else
mask_info = &msg_mask;
if (!mask_info)
return;
mask = (struct diag_msg_mask_t *)mask_info->ptr;
buf = mask_info->update_buf;
mutex_lock(&mask_info->lock);
switch (mask_info->status) {
case DIAG_CTRL_MASK_ALL_DISABLED:
mask_size = 0;
break;
case DIAG_CTRL_MASK_ALL_ENABLED:
mask_size = 1;
break;
case DIAG_CTRL_MASK_VALID:
break;
default:
pr_debug("diag: In %s, invalid status: %d\n", __func__,
mask_info->status);
goto err;
}
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
if (((first < mask->ssid_first) || (last > mask->ssid_last)) &&
first != ALL_SSID) {
continue;
}
mutex_lock(&mask->lock);
if (mask_info->status == DIAG_CTRL_MASK_VALID) {
mask_size = mask->ssid_last - mask->ssid_first + 1;
temp_len = mask_size * sizeof(uint32_t);
if (temp_len + header_len <= mask_info->update_buf_len)
goto proceed;
temp = krealloc(mask_info->update_buf, temp_len,
GFP_KERNEL);
if (!temp) {
pr_err("diag: In %s, unable to realloc msg_mask update buffer\n",
__func__);
mask_size = (mask_info->update_buf_len -
header_len) / sizeof(uint32_t);
} else {
mask_info->update_buf = temp;
mask_info->update_buf_len = temp_len;
pr_debug("diag: In %s, successfully reallocated msg_mask update buffer to len: %d\n",
__func__, mask_info->update_buf_len);
}
} else if (mask_info->status == DIAG_CTRL_MASK_ALL_ENABLED) {
mask_size = 1;
}
proceed:
header.cmd_type = DIAG_CTRL_MSG_F3_MASK;
header.status = mask_info->status;
header.stream_id = 1;
header.msg_mode = 0;
header.ssid_first = mask->ssid_first;
header.ssid_last = mask->ssid_last;
header.msg_mask_size = mask_size;
mask_size *= sizeof(uint32_t);
header.data_len = MSG_MASK_CTRL_HEADER_LEN + mask_size;
memcpy(buf, &header, header_len);
if (mask_size > 0)
memcpy(buf + header_len, mask->ptr, mask_size);
mutex_unlock(&mask->lock);
err = diagfwd_write(peripheral, TYPE_CNTL, buf,
header_len + mask_size);
if (err && err != -ENODEV)
pr_err_ratelimited("diag: Unable to send msg masks to peripheral %d\n",
peripheral);
if (first != ALL_SSID)
break;
}
err:
mutex_unlock(&mask_info->lock);
}
static void diag_send_time_sync_update(uint8_t peripheral)
{
struct diag_ctrl_msg_time_sync time_sync_msg;
int msg_size = sizeof(struct diag_ctrl_msg_time_sync);
int err = 0;
if (peripheral >= NUM_PERIPHERALS) {
pr_err("diag: In %s, Invalid peripheral, %d\n",
__func__, peripheral);
return;
}
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
pr_err("diag: In %s, control channel is not open, p: %d, %p\n",
__func__, peripheral, driver->diagfwd_cntl[peripheral]);
return;
}
mutex_lock(&driver->diag_cntl_mutex);
time_sync_msg.ctrl_pkt_id = DIAG_CTRL_MSG_TIME_SYNC_PKT;
time_sync_msg.ctrl_pkt_data_len = 5;
time_sync_msg.version = 1;
time_sync_msg.time_api = driver->uses_time_api;
err = diagfwd_write(peripheral, TYPE_CNTL, &time_sync_msg, msg_size);
if (err)
pr_err("diag: In %s, unable to write to peripheral: %d, type: %d, len: %d, err: %d\n",
__func__, peripheral, TYPE_CNTL,
msg_size, err);
mutex_unlock(&driver->diag_cntl_mutex);
}
static void diag_send_feature_mask_update(uint8_t peripheral)
{
void *buf = driver->buf_feature_mask_update;
int header_size = sizeof(struct diag_ctrl_feature_mask);
uint8_t feature_bytes[FEATURE_MASK_LEN] = {0, 0};
struct diag_ctrl_feature_mask feature_mask;
int total_len = 0;
int err = 0;
if (peripheral >= NUM_PERIPHERALS) {
pr_err("diag: In %s, Invalid peripheral, %d\n",
__func__, peripheral);
return;
}
if (!driver->diagfwd_cntl[peripheral] ||
!driver->diagfwd_cntl[peripheral]->ch_open) {
pr_err("diag: In %s, control channel is not open, p: %d, %p\n",
__func__, peripheral, driver->diagfwd_cntl[peripheral]);
return;
}
mutex_lock(&driver->diag_cntl_mutex);
/* send feature mask update */
feature_mask.ctrl_pkt_id = DIAG_CTRL_MSG_FEATURE;
feature_mask.ctrl_pkt_data_len = sizeof(uint32_t) + FEATURE_MASK_LEN;
feature_mask.feature_mask_len = FEATURE_MASK_LEN;
memcpy(buf, &feature_mask, header_size);
DIAG_SET_FEATURE_MASK(F_DIAG_FEATURE_MASK_SUPPORT);
DIAG_SET_FEATURE_MASK(F_DIAG_LOG_ON_DEMAND_APPS);
DIAG_SET_FEATURE_MASK(F_DIAG_STM);
if (driver->supports_separate_cmdrsp)
DIAG_SET_FEATURE_MASK(F_DIAG_REQ_RSP_SUPPORT);
if (driver->supports_apps_hdlc_encoding)
DIAG_SET_FEATURE_MASK(F_DIAG_APPS_HDLC_ENCODE);
DIAG_SET_FEATURE_MASK(F_DIAG_MASK_CENTRALIZATION);
if (driver->supports_sockets)
DIAG_SET_FEATURE_MASK(F_DIAG_SOCKETS_ENABLED);
memcpy(buf + header_size, &feature_bytes, FEATURE_MASK_LEN);
total_len = header_size + FEATURE_MASK_LEN;
err = diagfwd_write(peripheral, TYPE_CNTL, buf, total_len);
if (err) {
pr_err_ratelimited("diag: In %s, unable to write feature mask to peripheral: %d, type: %d, len: %d, err: %d\n",
__func__, peripheral, TYPE_CNTL,
total_len, err);
mutex_unlock(&driver->diag_cntl_mutex);
return;
}
driver->feature[peripheral].sent_feature_mask = 1;
mutex_unlock(&driver->diag_cntl_mutex);
}
static int diag_cmd_get_ssid_range(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
struct diag_msg_mask_t *mask_ptr = NULL;
struct diag_msg_ssid_query_t rsp;
struct diag_ssid_range_t ssid_range;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &msg_mask : info->msg_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
if (!diag_apps_responds())
return 0;
rsp.cmd_code = DIAG_CMD_MSG_CONFIG;
rsp.sub_cmd = DIAG_CMD_OP_GET_SSID_RANGE;
rsp.status = MSG_STATUS_SUCCESS;
rsp.padding = 0;
rsp.count = driver->msg_mask_tbl_count;
memcpy(dest_buf, &rsp, sizeof(rsp));
write_len += sizeof(rsp);
mask_ptr = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask_ptr++) {
if (write_len + sizeof(ssid_range) > dest_len) {
pr_err("diag: In %s, Truncating response due to size limitations of rsp buffer\n",
__func__);
break;
}
ssid_range.ssid_first = mask_ptr->ssid_first;
ssid_range.ssid_last = mask_ptr->ssid_last;
memcpy(dest_buf + write_len, &ssid_range, sizeof(ssid_range));
write_len += sizeof(ssid_range);
}
return write_len;
}
static int diag_cmd_get_build_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i = 0;
int write_len = 0;
int num_entries = 0;
int copy_len = 0;
struct diag_msg_mask_t *build_mask = NULL;
struct diag_build_mask_req_t *req = NULL;
struct diag_msg_build_mask_t rsp;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d\n",
__func__, src_buf, src_len, dest_buf, dest_len);
return -EINVAL;
}
if (!diag_apps_responds())
return 0;
req = (struct diag_build_mask_req_t *)src_buf;
rsp.cmd_code = DIAG_CMD_MSG_CONFIG;
rsp.sub_cmd = DIAG_CMD_OP_GET_BUILD_MASK;
rsp.ssid_first = req->ssid_first;
rsp.ssid_last = req->ssid_last;
rsp.status = MSG_STATUS_FAIL;
rsp.padding = 0;
build_mask = (struct diag_msg_mask_t *)msg_bt_mask.ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, build_mask++) {
if (build_mask->ssid_first != req->ssid_first)
continue;
num_entries = req->ssid_last - req->ssid_first + 1;
if (num_entries > build_mask->range) {
pr_warn("diag: In %s, truncating ssid range for ssid_first: %d ssid_last %d\n",
__func__, req->ssid_first, req->ssid_last);
num_entries = build_mask->range;
req->ssid_last = req->ssid_first + build_mask->range;
}
copy_len = num_entries * sizeof(uint32_t);
if (copy_len + sizeof(rsp) > dest_len)
copy_len = dest_len - sizeof(rsp);
memcpy(dest_buf + sizeof(rsp), build_mask->ptr, copy_len);
write_len += copy_len;
rsp.ssid_last = build_mask->ssid_last;
rsp.status = MSG_STATUS_SUCCESS;
break;
}
memcpy(dest_buf, &rsp, sizeof(rsp));
write_len += sizeof(rsp);
return write_len;
}
static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
uint32_t mask_size = 0;
struct diag_msg_mask_t *mask = NULL;
struct diag_build_mask_req_t *req = NULL;
struct diag_msg_build_mask_t rsp;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &msg_mask : info->msg_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
if (!diag_apps_responds())
return 0;
req = (struct diag_build_mask_req_t *)src_buf;
rsp.cmd_code = DIAG_CMD_MSG_CONFIG;
rsp.sub_cmd = DIAG_CMD_OP_GET_MSG_MASK;
rsp.ssid_first = req->ssid_first;
rsp.ssid_last = req->ssid_last;
rsp.status = MSG_STATUS_FAIL;
rsp.padding = 0;
mask = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
if ((req->ssid_first < mask->ssid_first) ||
(req->ssid_first > mask->ssid_last)) {
continue;
}
mask_size = mask->range * sizeof(uint32_t);
/* Copy msg mask only till the end of the rsp buffer */
if (mask_size + sizeof(rsp) > dest_len)
mask_size = dest_len - sizeof(rsp);
memcpy(dest_buf + sizeof(rsp), mask->ptr, mask_size);
write_len += mask_size;
rsp.status = MSG_STATUS_SUCCESS;
break;
}
memcpy(dest_buf, &rsp, sizeof(rsp));
write_len += sizeof(rsp);
return write_len;
}
static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
int header_len = sizeof(struct diag_msg_build_mask_t);
int found = 0;
uint32_t mask_size = 0;
uint32_t offset = 0;
struct diag_msg_mask_t *mask = NULL;
struct diag_msg_build_mask_t *req = NULL;
struct diag_msg_build_mask_t rsp;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &msg_mask : info->msg_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
req = (struct diag_msg_build_mask_t *)src_buf;
mutex_lock(&mask_info->lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
if ((req->ssid_first < mask->ssid_first) ||
(req->ssid_first > mask->ssid_last)) {
continue;
}
found = 1;
mutex_lock(&mask->lock);
if (req->ssid_last > mask->ssid_last) {
pr_debug("diag: Msg SSID range mismatch\n");
mask->ssid_last = req->ssid_last;
}
mask_size = req->ssid_last - req->ssid_first + 1;
if (mask_size > mask->range) {
pr_warn("diag: In %s, truncating ssid range, %d-%d to max allowed: %d\n",
__func__, mask->ssid_first, mask->ssid_last,
mask->range);
mask_size = mask->range;
mask->ssid_last = mask->ssid_first + mask->range;
}
offset = req->ssid_first - mask->ssid_first;
if (offset + mask_size > mask->range) {
pr_err("diag: In %s, Not enough space for msg mask, mask_size: %d\n",
__func__, mask_size);
mutex_unlock(&mask->lock);
break;
}
mask_size = mask_size * sizeof(uint32_t);
memcpy(mask->ptr + offset, src_buf + header_len, mask_size);
mutex_unlock(&mask->lock);
mask_info->status = DIAG_CTRL_MASK_VALID;
break;
}
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(MSG_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
rsp.cmd_code = DIAG_CMD_MSG_CONFIG;
rsp.sub_cmd = DIAG_CMD_OP_SET_MSG_MASK;
rsp.ssid_first = req->ssid_first;
rsp.ssid_last = req->ssid_last;
rsp.status = found;
rsp.padding = 0;
memcpy(dest_buf, &rsp, header_len);
write_len += header_len;
if (!found)
goto end;
if (mask_size + write_len > dest_len)
mask_size = dest_len - write_len;
memcpy(dest_buf + write_len, src_buf + header_len, mask_size);
write_len += mask_size;
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_msg_mask_update(i, req->ssid_first, req->ssid_last);
}
end:
return write_len;
}
static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
int header_len = sizeof(struct diag_msg_config_rsp_t);
struct diag_msg_config_rsp_t rsp;
struct diag_msg_config_rsp_t *req = NULL;
struct diag_msg_mask_t *mask = NULL;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &msg_mask : info->msg_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
req = (struct diag_msg_config_rsp_t *)src_buf;
mask = (struct diag_msg_mask_t *)mask_info->ptr;
mutex_lock(&mask_info->lock);
mask_info->status = (req->rt_mask) ? DIAG_CTRL_MASK_ALL_ENABLED :
DIAG_CTRL_MASK_ALL_DISABLED;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
mutex_lock(&mask->lock);
memset(mask->ptr, req->rt_mask,
mask->range * sizeof(uint32_t));
mutex_unlock(&mask->lock);
}
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(MSG_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
rsp.cmd_code = DIAG_CMD_MSG_CONFIG;
rsp.sub_cmd = DIAG_CMD_OP_SET_ALL_MSG_MASK;
rsp.status = MSG_STATUS_SUCCESS;
rsp.padding = 0;
rsp.rt_mask = req->rt_mask;
memcpy(dest_buf, &rsp, header_len);
write_len += header_len;
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_msg_mask_update(i, ALL_SSID, ALL_SSID);
}
return write_len;
}
static int diag_cmd_get_event_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int write_len = 0;
uint32_t mask_size;
struct diag_event_mask_config_t rsp;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d\n",
__func__, src_buf, src_len, dest_buf, dest_len);
return -EINVAL;
}
if (!diag_apps_responds())
return 0;
mask_size = EVENT_COUNT_TO_BYTES(driver->last_event_id);
if (mask_size + sizeof(rsp) > dest_len) {
pr_err("diag: In %s, invalid mask size: %d\n", __func__,
mask_size);
return -ENOMEM;
}
rsp.cmd_code = DIAG_CMD_GET_EVENT_MASK;
rsp.status = EVENT_STATUS_SUCCESS;
rsp.padding = 0;
rsp.num_bits = driver->last_event_id + 1;
memcpy(dest_buf, &rsp, sizeof(rsp));
write_len += sizeof(rsp);
memcpy(dest_buf + write_len, event_mask.ptr, mask_size);
write_len += mask_size;
return write_len;
}
static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
int mask_len = 0;
int header_len = sizeof(struct diag_event_mask_config_t);
struct diag_event_mask_config_t rsp;
struct diag_event_mask_config_t *req;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &event_mask : info->event_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
req = (struct diag_event_mask_config_t *)src_buf;
mask_len = EVENT_COUNT_TO_BYTES(req->num_bits);
if (mask_len <= 0 || mask_len > event_mask.mask_len) {
pr_err("diag: In %s, invalid event mask len: %d\n", __func__,
mask_len);
return -EIO;
}
mutex_lock(&mask_info->lock);
memcpy(mask_info->ptr, src_buf + header_len, mask_len);
mask_info->status = DIAG_CTRL_MASK_VALID;
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(EVENT_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
rsp.cmd_code = DIAG_CMD_SET_EVENT_MASK;
rsp.status = EVENT_STATUS_SUCCESS;
rsp.padding = 0;
rsp.num_bits = driver->last_event_id + 1;
memcpy(dest_buf, &rsp, header_len);
write_len += header_len;
memcpy(dest_buf + write_len, mask_info->ptr, mask_len);
write_len += mask_len;
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_event_mask_update(i);
}
return write_len;
}
static int diag_cmd_toggle_events(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
uint8_t toggle = 0;
struct diag_event_report_t header;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &event_mask : info->event_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
toggle = *(src_buf + 1);
mutex_lock(&mask_info->lock);
if (toggle) {
mask_info->status = DIAG_CTRL_MASK_ALL_ENABLED;
memset(mask_info->ptr, 0xFF, mask_info->mask_len);
} else {
mask_info->status = DIAG_CTRL_MASK_ALL_DISABLED;
memset(mask_info->ptr, 0, mask_info->mask_len);
}
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(EVENT_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
header.cmd_code = DIAG_CMD_EVENT_TOGGLE;
header.padding = 0;
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_event_mask_update(i);
}
memcpy(dest_buf, &header, sizeof(header));
write_len += sizeof(header);
return write_len;
}
static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int status = LOG_STATUS_INVALID;
int write_len = 0;
int read_len = 0;
int req_header_len = sizeof(struct diag_log_config_req_t);
int rsp_header_len = sizeof(struct diag_log_config_rsp_t);
uint32_t mask_size = 0;
struct diag_log_mask_t *log_item = NULL;
struct diag_log_config_req_t *req;
struct diag_log_config_rsp_t rsp;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &log_mask : info->log_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
if (!diag_apps_responds())
return 0;
req = (struct diag_log_config_req_t *)src_buf;
read_len += req_header_len;
rsp.cmd_code = DIAG_CMD_LOG_CONFIG;
rsp.padding[0] = 0;
rsp.padding[1] = 0;
rsp.padding[2] = 0;
rsp.sub_cmd = DIAG_CMD_OP_GET_LOG_MASK;
/*
* Don't copy the response header now. Copy at the end after
* calculating the status field value
*/
write_len += rsp_header_len;
log_item = (struct diag_log_mask_t *)mask_info->ptr;
for (i = 0; i < MAX_EQUIP_ID; i++, log_item++) {
if (log_item->equip_id != req->equip_id)
continue;
mutex_lock(&log_item->lock);
mask_size = LOG_ITEMS_TO_SIZE(log_item->num_items_tools);
/*
* Make sure we have space to fill the response in the buffer.
* Destination buffer should atleast be able to hold equip_id
* (uint32_t), num_items(uint32_t), mask (mask_size) and the
* response header.
*/
if ((mask_size + (2 * sizeof(uint32_t)) + rsp_header_len) >
dest_len) {
pr_err("diag: In %s, invalid length: %d, max rsp_len: %d\n",
__func__, mask_size, dest_len);
status = LOG_STATUS_FAIL;
mutex_unlock(&log_item->lock);
break;
}
*(uint32_t *)(dest_buf + write_len) = log_item->equip_id;
write_len += sizeof(uint32_t);
*(uint32_t *)(dest_buf + write_len) = log_item->num_items_tools;
write_len += sizeof(uint32_t);
if (mask_size > 0) {
memcpy(dest_buf + write_len, log_item->ptr, mask_size);
write_len += mask_size;
}
DIAG_LOG(DIAG_DEBUG_MASKS,
"sending log e %d num_items %d size %d\n",
log_item->equip_id, log_item->num_items_tools,
log_item->range_tools);
mutex_unlock(&log_item->lock);
status = LOG_STATUS_SUCCESS;
break;
}
rsp.status = status;
memcpy(dest_buf, &rsp, rsp_header_len);
return write_len;
}
static int diag_cmd_get_log_range(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
struct diag_log_config_rsp_t rsp;
struct diag_mask_info *mask_info = NULL;
struct diag_log_mask_t *mask = (struct diag_log_mask_t *)log_mask.ptr;
if (!diag_apps_responds())
return 0;
mask_info = (!info) ? &log_mask : info->log_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
rsp.cmd_code = DIAG_CMD_LOG_CONFIG;
rsp.padding[0] = 0;
rsp.padding[1] = 0;
rsp.padding[2] = 0;
rsp.sub_cmd = DIAG_CMD_OP_GET_LOG_RANGE;
rsp.status = LOG_STATUS_SUCCESS;
memcpy(dest_buf, &rsp, sizeof(rsp));
write_len += sizeof(rsp);
for (i = 0; i < MAX_EQUIP_ID && write_len < dest_len; i++, mask++) {
*(uint32_t *)(dest_buf + write_len) = mask->num_items_tools;
write_len += sizeof(uint32_t);
}
return write_len;
}
static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
int i;
int write_len = 0;
int status = LOG_STATUS_SUCCESS;
int read_len = 0;
int payload_len = 0;
int req_header_len = sizeof(struct diag_log_config_req_t);
int rsp_header_len = sizeof(struct diag_log_config_set_rsp_t);
uint32_t mask_size = 0;
struct diag_log_config_req_t *req;
struct diag_log_config_set_rsp_t rsp;
struct diag_log_mask_t *mask = NULL;
unsigned char *temp_buf = NULL;
struct diag_mask_info *mask_info = NULL;
mask_info = (!info) ? &log_mask : info->log_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
req = (struct diag_log_config_req_t *)src_buf;
read_len += req_header_len;
mask = (struct diag_log_mask_t *)mask_info->ptr;
if (req->equip_id >= MAX_EQUIP_ID) {
pr_err("diag: In %s, Invalid logging mask request, equip_id: %d\n",
__func__, req->equip_id);
status = LOG_STATUS_INVALID;
}
if (req->num_items == 0) {
pr_err("diag: In %s, Invalid number of items in log mask request, equip_id: %d\n",
__func__, req->equip_id);
status = LOG_STATUS_INVALID;
}
mutex_lock(&mask_info->lock);
for (i = 0; i < MAX_EQUIP_ID && !status; i++, mask++) {
if (mask->equip_id != req->equip_id)
continue;
mutex_lock(&mask->lock);
DIAG_LOG(DIAG_DEBUG_MASKS, "e: %d current: %d %d new: %d %d",
mask->equip_id, mask->num_items_tools,
mask->range_tools, req->num_items,
LOG_ITEMS_TO_SIZE(req->num_items));
/*
* If the size of the log mask cannot fit into our
* buffer, trim till we have space left in the buffer.
* num_items should then reflect the items that we have
* in our buffer.
*/
mask->num_items_tools = (req->num_items > MAX_ITEMS_ALLOWED) ?
MAX_ITEMS_ALLOWED : req->num_items;
mask_size = LOG_ITEMS_TO_SIZE(mask->num_items_tools);
memset(mask->ptr, 0, mask->range_tools);
if (mask_size > mask->range_tools) {
DIAG_LOG(DIAG_DEBUG_MASKS,
"log range mismatch, e: %d old: %d new: %d\n",
req->equip_id, mask->range_tools,
LOG_ITEMS_TO_SIZE(mask->num_items_tools));
/* Change in the mask reported by tools */
temp_buf = krealloc(mask->ptr, mask_size, GFP_KERNEL);
if (!temp_buf) {
mask_info->status = DIAG_CTRL_MASK_INVALID;
mutex_unlock(&mask->lock);
break;
}
mask->ptr = temp_buf;
memset(mask->ptr, 0, mask_size);
mask->range_tools = mask_size;
}
req->num_items = mask->num_items_tools;
if (mask_size > 0)
memcpy(mask->ptr, src_buf + read_len, mask_size);
DIAG_LOG(DIAG_DEBUG_MASKS,
"copying log mask, e %d num %d range %d size %d\n",
req->equip_id, mask->num_items_tools,
mask->range_tools, mask_size);
mutex_unlock(&mask->lock);
mask_info->status = DIAG_CTRL_MASK_VALID;
break;
}
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(LOG_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
payload_len = LOG_ITEMS_TO_SIZE(req->num_items);
if ((payload_len + rsp_header_len > dest_len) || (payload_len == 0)) {
pr_err("diag: In %s, invalid length, payload_len: %d, header_len: %d, dest_len: %d\n",
__func__, payload_len, rsp_header_len , dest_len);
status = LOG_STATUS_FAIL;
}
rsp.cmd_code = DIAG_CMD_LOG_CONFIG;
rsp.padding[0] = 0;
rsp.padding[1] = 0;
rsp.padding[2] = 0;
rsp.sub_cmd = DIAG_CMD_OP_SET_LOG_MASK;
rsp.status = status;
rsp.equip_id = req->equip_id;
rsp.num_items = req->num_items;
memcpy(dest_buf, &rsp, rsp_header_len);
write_len += rsp_header_len;
if (status != LOG_STATUS_SUCCESS)
goto end;
memcpy(dest_buf + write_len, src_buf + read_len, payload_len);
write_len += payload_len;
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_log_mask_update(i, req->equip_id);
}
end:
return write_len;
}
static int diag_cmd_disable_log_mask(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info)
{
struct diag_mask_info *mask_info = NULL;
struct diag_log_mask_t *mask = NULL;
struct diag_log_config_rsp_t header;
int write_len = 0;
int i;
mask_info = (!info) ? &log_mask : info->log_mask;
if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
!mask_info) {
pr_err("diag: Invalid input in %s, src_buf: %p, src_len: %d, dest_buf: %p, dest_len: %d, mask_info: %p\n",
__func__, src_buf, src_len, dest_buf, dest_len,
mask_info);
return -EINVAL;
}
mask = (struct diag_log_mask_t *)mask_info->ptr;
for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
mutex_lock(&mask->lock);
memset(mask->ptr, 0, mask->range);
mutex_unlock(&mask->lock);
}
mask_info->status = DIAG_CTRL_MASK_ALL_DISABLED;
if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(LOG_MASKS_TYPE);
/*
* Apps processor must send the response to this command. Frame the
* response.
*/
header.cmd_code = DIAG_CMD_LOG_CONFIG;
header.padding[0] = 0;
header.padding[1] = 0;
header.padding[2] = 0;
header.sub_cmd = DIAG_CMD_OP_LOG_DISABLE;
header.status = LOG_STATUS_SUCCESS;
memcpy(dest_buf, &header, sizeof(struct diag_log_config_rsp_t));
write_len += sizeof(struct diag_log_config_rsp_t);
for (i = 0; i < NUM_PERIPHERALS; i++) {
if (!diag_check_update(i))
continue;
diag_send_log_mask_update(i, ALL_EQUIP_ID);
}
return write_len;
}
int diag_create_msg_mask_table_entry(struct diag_msg_mask_t *msg_mask,
struct diag_ssid_range_t *range)
{
if (!msg_mask || !range)
return -EIO;
if (range->ssid_last < range->ssid_first)
return -EINVAL;
msg_mask->ssid_first = range->ssid_first;
msg_mask->ssid_last = range->ssid_last;
msg_mask->range = msg_mask->ssid_last - msg_mask->ssid_first + 1;
if (msg_mask->range < MAX_SSID_PER_RANGE)
msg_mask->range = MAX_SSID_PER_RANGE;
mutex_init(&msg_mask->lock);
if (msg_mask->range > 0) {
msg_mask->ptr = kzalloc(msg_mask->range * sizeof(uint32_t),
GFP_KERNEL);
if (!msg_mask->ptr)
return -ENOMEM;
kmemleak_not_leak(msg_mask->ptr);
}
return 0;
}
static int diag_create_msg_mask_table(void)
{
int i;
int err = 0;
struct diag_msg_mask_t *mask = (struct diag_msg_mask_t *)msg_mask.ptr;
struct diag_ssid_range_t range;
mutex_lock(&msg_mask.lock);
driver->msg_mask_tbl_count = MSG_MASK_TBL_CNT;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
range.ssid_first = msg_mask_tbl[i].ssid_first;
range.ssid_last = msg_mask_tbl[i].ssid_last;
err = diag_create_msg_mask_table_entry(mask, &range);
if (err)
break;
}
mutex_unlock(&msg_mask.lock);
return err;
}
static int diag_create_build_time_mask(void)
{
int i;
int err = 0;
const uint32_t *tbl = NULL;
uint32_t tbl_size = 0;
struct diag_msg_mask_t *build_mask = NULL;
struct diag_ssid_range_t range;
mutex_lock(&msg_bt_mask.lock);
build_mask = (struct diag_msg_mask_t *)msg_bt_mask.ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, build_mask++) {
range.ssid_first = msg_mask_tbl[i].ssid_first;
range.ssid_last = msg_mask_tbl[i].ssid_last;
err = diag_create_msg_mask_table_entry(build_mask, &range);
if (err)
break;
switch (build_mask->ssid_first) {
case MSG_SSID_0:
tbl = msg_bld_masks_0;
tbl_size = sizeof(msg_bld_masks_0);
break;
case MSG_SSID_1:
tbl = msg_bld_masks_1;
tbl_size = sizeof(msg_bld_masks_1);
break;
case MSG_SSID_2:
tbl = msg_bld_masks_2;
tbl_size = sizeof(msg_bld_masks_2);
break;
case MSG_SSID_3:
tbl = msg_bld_masks_3;
tbl_size = sizeof(msg_bld_masks_3);
break;
case MSG_SSID_4:
tbl = msg_bld_masks_4;
tbl_size = sizeof(msg_bld_masks_4);
break;
case MSG_SSID_5:
tbl = msg_bld_masks_5;
tbl_size = sizeof(msg_bld_masks_5);
break;
case MSG_SSID_6:
tbl = msg_bld_masks_6;
tbl_size = sizeof(msg_bld_masks_6);
break;
case MSG_SSID_7:
tbl = msg_bld_masks_7;
tbl_size = sizeof(msg_bld_masks_7);
break;
case MSG_SSID_8:
tbl = msg_bld_masks_8;
tbl_size = sizeof(msg_bld_masks_8);
break;
case MSG_SSID_9:
tbl = msg_bld_masks_9;
tbl_size = sizeof(msg_bld_masks_9);
break;
case MSG_SSID_10:
tbl = msg_bld_masks_10;
tbl_size = sizeof(msg_bld_masks_10);
break;
case MSG_SSID_11:
tbl = msg_bld_masks_11;
tbl_size = sizeof(msg_bld_masks_11);
break;
case MSG_SSID_12:
tbl = msg_bld_masks_12;
tbl_size = sizeof(msg_bld_masks_12);
break;
case MSG_SSID_13:
tbl = msg_bld_masks_13;
tbl_size = sizeof(msg_bld_masks_13);
break;
case MSG_SSID_14:
tbl = msg_bld_masks_14;
tbl_size = sizeof(msg_bld_masks_14);
break;
case MSG_SSID_15:
tbl = msg_bld_masks_15;
tbl_size = sizeof(msg_bld_masks_15);
break;
case MSG_SSID_16:
tbl = msg_bld_masks_16;
tbl_size = sizeof(msg_bld_masks_16);
break;
case MSG_SSID_17:
tbl = msg_bld_masks_17;
tbl_size = sizeof(msg_bld_masks_17);
break;
case MSG_SSID_18:
tbl = msg_bld_masks_18;
tbl_size = sizeof(msg_bld_masks_18);
break;
case MSG_SSID_19:
tbl = msg_bld_masks_19;
tbl_size = sizeof(msg_bld_masks_19);
break;
case MSG_SSID_20:
tbl = msg_bld_masks_20;
tbl_size = sizeof(msg_bld_masks_20);
break;
case MSG_SSID_21:
tbl = msg_bld_masks_21;
tbl_size = sizeof(msg_bld_masks_21);
break;
case MSG_SSID_22:
tbl = msg_bld_masks_22;
tbl_size = sizeof(msg_bld_masks_22);
break;
}
if (!tbl)
continue;
if (tbl_size > build_mask->range * sizeof(uint32_t)) {
pr_warn("diag: In %s, table %d has more ssid than max, ssid_first: %d, ssid_last: %d\n",
__func__, i, build_mask->ssid_first,
build_mask->ssid_last);
tbl_size = build_mask->range * sizeof(uint32_t);
}
memcpy(build_mask->ptr, tbl, tbl_size);
}
mutex_unlock(&msg_bt_mask.lock);
return err;
}
static int diag_create_log_mask_table(void)
{
struct diag_log_mask_t *mask = NULL;
uint8_t i;
int err = 0;
mutex_lock(&log_mask.lock);
mask = (struct diag_log_mask_t *)(log_mask.ptr);
for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
mask->equip_id = i;
mask->num_items = LOG_GET_ITEM_NUM(log_code_last_tbl[i]);
mask->num_items_tools = mask->num_items;
mutex_init(&mask->lock);
if (LOG_ITEMS_TO_SIZE(mask->num_items) > MAX_ITEMS_PER_EQUIP_ID)
mask->range = LOG_ITEMS_TO_SIZE(mask->num_items);
else
mask->range = MAX_ITEMS_PER_EQUIP_ID;
mask->range_tools = mask->range;
mask->ptr = kzalloc(mask->range, GFP_KERNEL);
if (!mask->ptr) {
err = -ENOMEM;
break;
}
kmemleak_not_leak(mask->ptr);
}
mutex_unlock(&log_mask.lock);
return err;
}
static int __diag_mask_init(struct diag_mask_info *mask_info, int mask_len,
int update_buf_len)
{
if (!mask_info || mask_len < 0 || update_buf_len < 0)
return -EINVAL;
mask_info->status = DIAG_CTRL_MASK_INVALID;
mask_info->mask_len = mask_len;
mask_info->update_buf_len = update_buf_len;
if (mask_len > 0) {
mask_info->ptr = kzalloc(mask_len, GFP_KERNEL);
if (!mask_info->ptr)
return -ENOMEM;
kmemleak_not_leak(mask_info->ptr);
}
if (update_buf_len > 0) {
mask_info->update_buf = kzalloc(update_buf_len, GFP_KERNEL);
if (!mask_info->update_buf) {
kfree(mask_info->ptr);
return -ENOMEM;
}
kmemleak_not_leak(mask_info->update_buf);
}
mutex_init(&mask_info->lock);
return 0;
}
static void __diag_mask_exit(struct diag_mask_info *mask_info)
{
if (!mask_info)
return;
mutex_lock(&mask_info->lock);
kfree(mask_info->ptr);
mask_info->ptr = NULL;
kfree(mask_info->update_buf);
mask_info->update_buf = NULL;
mutex_unlock(&mask_info->lock);
}
int diag_log_mask_copy(struct diag_mask_info *dest, struct diag_mask_info *src)
{
int i;
int err = 0;
struct diag_log_mask_t *src_mask = NULL;
struct diag_log_mask_t *dest_mask = NULL;
if (!src)
return -EINVAL;
err = __diag_mask_init(dest, LOG_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
mutex_lock(&dest->lock);
src_mask = (struct diag_log_mask_t *)(src->ptr);
dest_mask = (struct diag_log_mask_t *)(dest->ptr);
dest->mask_len = src->mask_len;
dest->status = src->status;
for (i = 0; i < MAX_EQUIP_ID; i++, src_mask++, dest_mask++) {
dest_mask->equip_id = src_mask->equip_id;
dest_mask->num_items = src_mask->num_items;
dest_mask->num_items_tools = src_mask->num_items_tools;
mutex_init(&dest_mask->lock);
dest_mask->range = src_mask->range;
dest_mask->range_tools = src_mask->range_tools;
dest_mask->ptr = kzalloc(dest_mask->range_tools, GFP_KERNEL);
if (!dest_mask->ptr) {
err = -ENOMEM;
break;
}
kmemleak_not_leak(dest_mask->ptr);
memcpy(dest_mask->ptr, src_mask->ptr, dest_mask->range_tools);
}
mutex_unlock(&dest->lock);
return err;
}
void diag_log_mask_free(struct diag_mask_info *mask_info)
{
int i;
struct diag_log_mask_t *mask = NULL;
if (!mask_info)
return;
mutex_lock(&mask_info->lock);
mask = (struct diag_log_mask_t *)mask_info->ptr;
for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
kfree(mask->ptr);
mask->ptr = NULL;
}
mutex_unlock(&mask_info->lock);
__diag_mask_exit(mask_info);
}
static int diag_msg_mask_init(void)
{
int err = 0;
int i;
err = __diag_mask_init(&msg_mask, MSG_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
err = diag_create_msg_mask_table();
if (err) {
pr_err("diag: Unable to create msg masks, err: %d\n", err);
return err;
}
driver->msg_mask = &msg_mask;
for (i = 0; i < NUM_PERIPHERALS; i++)
driver->max_ssid_count[i] = 0;
return 0;
}
int diag_msg_mask_copy(struct diag_mask_info *dest, struct diag_mask_info *src)
{
int i;
int err = 0;
struct diag_msg_mask_t *src_mask = NULL;
struct diag_msg_mask_t *dest_mask = NULL;
struct diag_ssid_range_t range;
if (!src || !dest)
return -EINVAL;
err = __diag_mask_init(dest, MSG_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
mutex_lock(&dest->lock);
src_mask = (struct diag_msg_mask_t *)src->ptr;
dest_mask = (struct diag_msg_mask_t *)dest->ptr;
dest->mask_len = src->mask_len;
dest->status = src->status;
for (i = 0; i < driver->msg_mask_tbl_count; i++) {
range.ssid_first = src_mask->ssid_first;
range.ssid_last = src_mask->ssid_last;
err = diag_create_msg_mask_table_entry(dest_mask, &range);
if (err)
break;
memcpy(dest_mask->ptr, src_mask->ptr,
dest_mask->range * sizeof(uint32_t));
src_mask++;
dest_mask++;
}
mutex_unlock(&dest->lock);
return err;
}
void diag_msg_mask_free(struct diag_mask_info *mask_info)
{
int i;
struct diag_msg_mask_t *mask = NULL;
if (!mask_info)
return;
mutex_lock(&mask_info->lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
kfree(mask->ptr);
mask->ptr = NULL;
}
mutex_unlock(&mask_info->lock);
__diag_mask_exit(mask_info);
}
static void diag_msg_mask_exit(void)
{
int i;
struct diag_msg_mask_t *mask = NULL;
mask = (struct diag_msg_mask_t *)(msg_mask.ptr);
if (mask) {
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++)
kfree(mask->ptr);
kfree(msg_mask.ptr);
}
kfree(msg_mask.update_buf);
}
static int diag_build_time_mask_init(void)
{
int err = 0;
/* There is no need for update buffer for Build Time masks */
err = __diag_mask_init(&msg_bt_mask, MSG_MASK_SIZE, 0);
if (err)
return err;
err = diag_create_build_time_mask();
if (err) {
pr_err("diag: Unable to create msg build time masks, err: %d\n",
err);
return err;
}
driver->build_time_mask = &msg_bt_mask;
return 0;
}
static void diag_build_time_mask_exit(void)
{
int i;
struct diag_msg_mask_t *mask = NULL;
mask = (struct diag_msg_mask_t *)(msg_bt_mask.ptr);
if (mask) {
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++)
kfree(mask->ptr);
kfree(msg_mask.ptr);
}
}
static int diag_log_mask_init(void)
{
int err = 0;
int i;
err = __diag_mask_init(&log_mask, LOG_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
err = diag_create_log_mask_table();
if (err)
return err;
driver->log_mask = &log_mask;
for (i = 0; i < NUM_PERIPHERALS; i++)
driver->num_equip_id[i] = 0;
return 0;
}
static void diag_log_mask_exit(void)
{
int i;
struct diag_log_mask_t *mask = NULL;
mask = (struct diag_log_mask_t *)(log_mask.ptr);
if (mask) {
for (i = 0; i < MAX_EQUIP_ID; i++, mask++)
kfree(mask->ptr);
kfree(log_mask.ptr);
}
kfree(log_mask.update_buf);
}
static int diag_event_mask_init(void)
{
int err = 0;
int i;
err = __diag_mask_init(&event_mask, EVENT_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
driver->event_mask_size = EVENT_MASK_SIZE;
driver->last_event_id = APPS_EVENT_LAST_ID;
driver->event_mask = &event_mask;
for (i = 0; i < NUM_PERIPHERALS; i++)
driver->num_event_id[i] = 0;
return 0;
}
int diag_event_mask_copy(struct diag_mask_info *dest,
struct diag_mask_info *src)
{
int err = 0;
if (!src || !dest)
return -EINVAL;
err = __diag_mask_init(dest, EVENT_MASK_SIZE, APPS_BUF_SIZE);
if (err)
return err;
mutex_lock(&dest->lock);
dest->mask_len = src->mask_len;
dest->status = src->status;
memcpy(dest->ptr, src->ptr, dest->mask_len);
mutex_unlock(&dest->lock);
return err;
}
void diag_event_mask_free(struct diag_mask_info *mask_info)
{
if (!mask_info)
return;
__diag_mask_exit(mask_info);
}
static void diag_event_mask_exit(void)
{
kfree(event_mask.ptr);
kfree(event_mask.update_buf);
}
int diag_copy_to_user_msg_mask(char __user *buf, size_t count,
struct diag_md_session_t *info)
{
int i;
int err = 0;
int len = 0;
int copy_len = 0;
int total_len = 0;
struct diag_msg_mask_userspace_t header;
struct diag_mask_info *mask_info = NULL;
struct diag_msg_mask_t *mask = NULL;
unsigned char *ptr = NULL;
if (!buf || count == 0)
return -EINVAL;
mask_info = (!info) ? &msg_mask : info->msg_mask;
if (!mask_info)
return -EIO;
mutex_lock(&mask_info->lock);
mask = (struct diag_msg_mask_t *)(mask_info->ptr);
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
ptr = mask_info->update_buf;
len = 0;
mutex_lock(&mask->lock);
header.ssid_first = mask->ssid_first;
header.ssid_last = mask->ssid_last;
header.range = mask->range;
memcpy(ptr, &header, sizeof(header));
len += sizeof(header);
copy_len = (sizeof(uint32_t) * mask->range);
if ((len + copy_len) > mask_info->update_buf_len) {
pr_err("diag: In %s, no space to update msg mask, first: %d, last: %d\n",
__func__, mask->ssid_first, mask->ssid_last);
mutex_unlock(&mask->lock);
continue;
}
memcpy(ptr + len, mask->ptr, copy_len);
len += copy_len;
mutex_unlock(&mask->lock);
/* + sizeof(int) to account for data_type already in buf */
if (total_len + sizeof(int) + len > count) {
pr_err("diag: In %s, unable to send msg masks to user space, total_len: %d, count: %zu\n",
__func__, total_len, count);
err = -ENOMEM;
break;
}
err = copy_to_user(buf + total_len, (void *)ptr, len);
if (err) {
pr_err("diag: In %s Unable to send msg masks to user space clients, err: %d\n",
__func__, err);
break;
}
total_len += len;
}
mutex_unlock(&mask_info->lock);
return err ? err : total_len;
}
int diag_copy_to_user_log_mask(char __user *buf, size_t count,
struct diag_md_session_t *info)
{
int i;
int err = 0;
int len = 0;
int copy_len = 0;
int total_len = 0;
struct diag_log_mask_userspace_t header;
struct diag_log_mask_t *mask = NULL;
struct diag_mask_info *mask_info = NULL;
unsigned char *ptr = NULL;
if (!buf || count == 0)
return -EINVAL;
mask_info = (!info) ? &log_mask : info->log_mask;
if (!mask_info)
return -EIO;
mutex_lock(&mask_info->lock);
mask = (struct diag_log_mask_t *)(mask_info->ptr);
for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
ptr = mask_info->update_buf;
len = 0;
mutex_lock(&mask->lock);
header.equip_id = mask->equip_id;
header.num_items = mask->num_items_tools;
memcpy(ptr, &header, sizeof(header));
len += sizeof(header);
copy_len = LOG_ITEMS_TO_SIZE(header.num_items);
if ((len + copy_len) > mask_info->update_buf_len) {
pr_err("diag: In %s, no space to update log mask, equip_id: %d\n",
__func__, mask->equip_id);
mutex_unlock(&mask->lock);
continue;
}
memcpy(ptr + len, mask->ptr, copy_len);
len += copy_len;
mutex_unlock(&mask->lock);
/* + sizeof(int) to account for data_type already in buf */
if (total_len + sizeof(int) + len > count) {
pr_err("diag: In %s, unable to send log masks to user space, total_len: %d, count: %zu\n",
__func__, total_len, count);
err = -ENOMEM;
break;
}
err = copy_to_user(buf + total_len, (void *)ptr, len);
if (err) {
pr_err("diag: In %s Unable to send log masks to user space clients, err: %d\n",
__func__, err);
break;
}
total_len += len;
}
mutex_unlock(&mask_info->lock);
return err ? err : total_len;
}
void diag_send_updates_peripheral(uint8_t peripheral)
{
diag_send_feature_mask_update(peripheral);
if (driver->time_sync_enabled)
diag_send_time_sync_update(peripheral);
diag_send_msg_mask_update(peripheral, ALL_SSID, ALL_SSID);
diag_send_log_mask_update(peripheral, ALL_EQUIP_ID);
diag_send_event_mask_update(peripheral);
diag_send_real_time_update(peripheral,
driver->real_time_mode[DIAG_LOCAL_PROC]);
diag_send_peripheral_buffering_mode(
&driver->buffering_mode[peripheral]);
}
int diag_process_apps_masks(unsigned char *buf, int len,
struct diag_md_session_t *info)
{
int size = 0;
int sub_cmd = 0;
int (*hdlr)(unsigned char *src_buf, int src_len,
unsigned char *dest_buf, int dest_len,
struct diag_md_session_t *info) = NULL;
if (!buf || len <= 0)
return -EINVAL;
if (*buf == DIAG_CMD_LOG_CONFIG) {
sub_cmd = *(int *)(buf + sizeof(int));
switch (sub_cmd) {
case DIAG_CMD_OP_LOG_DISABLE:
hdlr = diag_cmd_disable_log_mask;
break;
case DIAG_CMD_OP_GET_LOG_RANGE:
hdlr = diag_cmd_get_log_range;
break;
case DIAG_CMD_OP_SET_LOG_MASK:
hdlr = diag_cmd_set_log_mask;
break;
case DIAG_CMD_OP_GET_LOG_MASK:
hdlr = diag_cmd_get_log_mask;
break;
}
} else if (*buf == DIAG_CMD_MSG_CONFIG) {
sub_cmd = *(uint8_t *)(buf + sizeof(uint8_t));
switch (sub_cmd) {
case DIAG_CMD_OP_GET_SSID_RANGE:
hdlr = diag_cmd_get_ssid_range;
break;
case DIAG_CMD_OP_GET_BUILD_MASK:
hdlr = diag_cmd_get_build_mask;
break;
case DIAG_CMD_OP_GET_MSG_MASK:
hdlr = diag_cmd_get_msg_mask;
break;
case DIAG_CMD_OP_SET_MSG_MASK:
hdlr = diag_cmd_set_msg_mask;
break;
case DIAG_CMD_OP_SET_ALL_MSG_MASK:
hdlr = diag_cmd_set_all_msg_mask;
break;
}
} else if (*buf == DIAG_CMD_GET_EVENT_MASK) {
hdlr = diag_cmd_get_event_mask;
} else if (*buf == DIAG_CMD_SET_EVENT_MASK) {
hdlr = diag_cmd_update_event_mask;
} else if (*buf == DIAG_CMD_EVENT_TOGGLE) {
hdlr = diag_cmd_toggle_events;
}
if (hdlr)
size = hdlr(buf, len, driver->apps_rsp_buf,
DIAG_MAX_RSP_SIZE, info);
return (size > 0) ? size : 0;
}
int diag_masks_init(void)
{
int err = 0;
err = diag_msg_mask_init();
if (err)
goto fail;
err = diag_build_time_mask_init();
if (err)
goto fail;
err = diag_log_mask_init();
if (err)
goto fail;
err = diag_event_mask_init();
if (err)
goto fail;
if (driver->buf_feature_mask_update == NULL) {
driver->buf_feature_mask_update = kzalloc(sizeof(
struct diag_ctrl_feature_mask) +
FEATURE_MASK_LEN, GFP_KERNEL);
if (driver->buf_feature_mask_update == NULL)
goto fail;
kmemleak_not_leak(driver->buf_feature_mask_update);
}
return 0;
fail:
pr_err("diag: Could not initialize diag mask buffers\n");
diag_masks_exit();
return -ENOMEM;
}
void diag_masks_exit(void)
{
diag_msg_mask_exit();
diag_build_time_mask_exit();
diag_log_mask_exit();
diag_event_mask_exit();
kfree(driver->buf_feature_mask_update);
}
| gpl-2.0 |
xiaoleigua/linux | include/linux/fs.h | 102049 | #ifndef _LINUX_FS_H
#define _LINUX_FS_H
#include <linux/linkage.h>
#include <linux/wait.h>
#include <linux/kdev_t.h>
#include <linux/dcache.h>
#include <linux/path.h>
#include <linux/stat.h>
#include <linux/cache.h>
#include <linux/list.h>
#include <linux/list_lru.h>
#include <linux/llist.h>
#include <linux/radix-tree.h>
#include <linux/rbtree.h>
#include <linux/init.h>
#include <linux/pid.h>
#include <linux/bug.h>
#include <linux/mutex.h>
#include <linux/rwsem.h>
#include <linux/capability.h>
#include <linux/semaphore.h>
#include <linux/fiemap.h>
#include <linux/rculist_bl.h>
#include <linux/atomic.h>
#include <linux/shrinker.h>
#include <linux/migrate_mode.h>
#include <linux/uidgid.h>
#include <linux/lockdep.h>
#include <linux/percpu-rwsem.h>
#include <linux/blk_types.h>
#include <asm/byteorder.h>
#include <uapi/linux/fs.h>
struct backing_dev_info;
struct bdi_writeback;
struct export_operations;
struct hd_geometry;
struct iovec;
struct kiocb;
struct kobject;
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
struct cred;
struct swap_info_struct;
struct seq_file;
struct workqueue_struct;
struct iov_iter;
struct vm_fault;
extern void __init inode_init(void);
extern void __init inode_init_early(void);
extern void __init files_init(void);
extern void __init files_maxfiles_init(void);
extern struct files_stat_struct files_stat;
extern unsigned long get_max_files(void);
extern int sysctl_nr_open;
extern struct inodes_stat_t inodes_stat;
extern int leases_enable, lease_break_time;
extern int sysctl_protected_symlinks;
extern int sysctl_protected_hardlinks;
struct buffer_head;
typedef int (get_block_t)(struct inode *inode, sector_t iblock,
struct buffer_head *bh_result, int create);
typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
ssize_t bytes, void *private);
typedef void (dax_iodone_t)(struct buffer_head *bh_map, int uptodate);
#define MAY_EXEC 0x00000001
#define MAY_WRITE 0x00000002
#define MAY_READ 0x00000004
#define MAY_APPEND 0x00000008
#define MAY_ACCESS 0x00000010
#define MAY_OPEN 0x00000020
#define MAY_CHDIR 0x00000040
/* called from RCU mode, don't block */
#define MAY_NOT_BLOCK 0x00000080
/*
* flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
* to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
*/
/* file is open for reading */
#define FMODE_READ ((__force fmode_t)0x1)
/* file is open for writing */
#define FMODE_WRITE ((__force fmode_t)0x2)
/* file is seekable */
#define FMODE_LSEEK ((__force fmode_t)0x4)
/* file can be accessed using pread */
#define FMODE_PREAD ((__force fmode_t)0x8)
/* file can be accessed using pwrite */
#define FMODE_PWRITE ((__force fmode_t)0x10)
/* File is opened for execution with sys_execve / sys_uselib */
#define FMODE_EXEC ((__force fmode_t)0x20)
/* File is opened with O_NDELAY (only set for block devices) */
#define FMODE_NDELAY ((__force fmode_t)0x40)
/* File is opened with O_EXCL (only set for block devices) */
#define FMODE_EXCL ((__force fmode_t)0x80)
/* File is opened using open(.., 3, ..) and is writeable only for ioctls
(specialy hack for floppy.c) */
#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
/* 32bit hashes as llseek() offset (for directories) */
#define FMODE_32BITHASH ((__force fmode_t)0x200)
/* 64bit hashes as llseek() offset (for directories) */
#define FMODE_64BITHASH ((__force fmode_t)0x400)
/*
* Don't update ctime and mtime.
*
* Currently a special hack for the XFS open_by_handle ioctl, but we'll
* hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
*/
#define FMODE_NOCMTIME ((__force fmode_t)0x800)
/* Expect random access pattern */
#define FMODE_RANDOM ((__force fmode_t)0x1000)
/* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
/* File is opened with O_PATH; almost nothing can be done with it */
#define FMODE_PATH ((__force fmode_t)0x4000)
/* File needs atomic accesses to f_pos */
#define FMODE_ATOMIC_POS ((__force fmode_t)0x8000)
/* Write access to underlying fs */
#define FMODE_WRITER ((__force fmode_t)0x10000)
/* Has read method(s) */
#define FMODE_CAN_READ ((__force fmode_t)0x20000)
/* Has write method(s) */
#define FMODE_CAN_WRITE ((__force fmode_t)0x40000)
/* File was opened by fanotify and shouldn't generate fanotify events */
#define FMODE_NONOTIFY ((__force fmode_t)0x4000000)
/*
* Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
* that indicates that they should check the contents of the iovec are
* valid, but not check the memory that the iovec elements
* points too.
*/
#define CHECK_IOVEC_ONLY -1
/*
* The below are the various read and write types that we support. Some of
* them include behavioral modifiers that send information down to the
* block layer and IO scheduler. Terminology:
*
* The block layer uses device plugging to defer IO a little bit, in
* the hope that we will see more IO very shortly. This increases
* coalescing of adjacent IO and thus reduces the number of IOs we
* have to send to the device. It also allows for better queuing,
* if the IO isn't mergeable. If the caller is going to be waiting
* for the IO, then he must ensure that the device is unplugged so
* that the IO is dispatched to the driver.
*
* All IO is handled async in Linux. This is fine for background
* writes, but for reads or writes that someone waits for completion
* on, we want to notify the block layer and IO scheduler so that they
* know about it. That allows them to make better scheduling
* decisions. So when the below references 'sync' and 'async', it
* is referencing this priority hint.
*
* With that in mind, the available types are:
*
* READ A normal read operation. Device will be plugged.
* READ_SYNC A synchronous read. Device is not plugged, caller can
* immediately wait on this read without caring about
* unplugging.
* READA Used for read-ahead operations. Lower priority, and the
* block layer could (in theory) choose to ignore this
* request if it runs into resource problems.
* WRITE A normal async write. Device will be plugged.
* WRITE_SYNC Synchronous write. Identical to WRITE, but passes down
* the hint that someone will be waiting on this IO
* shortly. The write equivalent of READ_SYNC.
* WRITE_ODIRECT Special case write for O_DIRECT only.
* WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush.
* WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on
* non-volatile media on completion.
* WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded
* by a cache flush and data is guaranteed to be on
* non-volatile media on completion.
*
*/
#define RW_MASK REQ_WRITE
#define RWA_MASK REQ_RAHEAD
#define READ 0
#define WRITE RW_MASK
#define READA RWA_MASK
#define READ_SYNC (READ | REQ_SYNC)
#define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE)
#define WRITE_ODIRECT (WRITE | REQ_SYNC)
#define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH)
#define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA)
#define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
/*
* Attribute flags. These should be or-ed together to figure out what
* has been changed!
*/
#define ATTR_MODE (1 << 0)
#define ATTR_UID (1 << 1)
#define ATTR_GID (1 << 2)
#define ATTR_SIZE (1 << 3)
#define ATTR_ATIME (1 << 4)
#define ATTR_MTIME (1 << 5)
#define ATTR_CTIME (1 << 6)
#define ATTR_ATIME_SET (1 << 7)
#define ATTR_MTIME_SET (1 << 8)
#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
#define ATTR_ATTR_FLAG (1 << 10)
#define ATTR_KILL_SUID (1 << 11)
#define ATTR_KILL_SGID (1 << 12)
#define ATTR_FILE (1 << 13)
#define ATTR_KILL_PRIV (1 << 14)
#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
#define ATTR_TIMES_SET (1 << 16)
/*
* Whiteout is represented by a char device. The following constants define the
* mode and device number to use.
*/
#define WHITEOUT_MODE 0
#define WHITEOUT_DEV 0
/*
* This is the Inode Attributes structure, used for notify_change(). It
* uses the above definitions as flags, to know which values have changed.
* Also, in this manner, a Filesystem can look at only the values it cares
* about. Basically, these are the attributes that the VFS layer can
* request to change from the FS layer.
*
* Derek Atkins <[email protected]> 94-10-20
*/
struct iattr {
unsigned int ia_valid;
umode_t ia_mode;
kuid_t ia_uid;
kgid_t ia_gid;
loff_t ia_size;
struct timespec ia_atime;
struct timespec ia_mtime;
struct timespec ia_ctime;
/*
* Not an attribute, but an auxiliary info for filesystems wanting to
* implement an ftruncate() like method. NOTE: filesystem should
* check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
*/
struct file *ia_file;
};
/*
* Includes for diskquotas.
*/
#include <linux/quota.h>
/*
* Maximum number of layers of fs stack. Needs to be limited to
* prevent kernel stack overflow
*/
#define FILESYSTEM_MAX_STACK_DEPTH 2
/**
* enum positive_aop_returns - aop return codes with specific semantics
*
* @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
* completed, that the page is still locked, and
* should be considered active. The VM uses this hint
* to return the page to the active list -- it won't
* be a candidate for writeback again in the near
* future. Other callers must be careful to unlock
* the page if they get this return. Returned by
* writepage();
*
* @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
* unlocked it and the page might have been truncated.
* The caller should back up to acquiring a new page and
* trying again. The aop will be taking reasonable
* precautions not to livelock. If the caller held a page
* reference, it should drop it before retrying. Returned
* by readpage().
*
* address_space_operation functions return these large constants to indicate
* special semantics to the caller. These are much larger than the bytes in a
* page to allow for functions that return the number of bytes operated on in a
* given page.
*/
enum positive_aop_returns {
AOP_WRITEPAGE_ACTIVATE = 0x80000,
AOP_TRUNCATED_PAGE = 0x80001,
};
#define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */
#define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */
#define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct
* helper code (eg buffer layer)
* to clear GFP_FS from alloc */
/*
* oh the beauties of C type declarations.
*/
struct page;
struct address_space;
struct writeback_control;
#define IOCB_EVENTFD (1 << 0)
#define IOCB_APPEND (1 << 1)
#define IOCB_DIRECT (1 << 2)
struct kiocb {
struct file *ki_filp;
loff_t ki_pos;
void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
void *private;
int ki_flags;
};
static inline bool is_sync_kiocb(struct kiocb *kiocb)
{
return kiocb->ki_complete == NULL;
}
static inline int iocb_flags(struct file *file);
static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
{
*kiocb = (struct kiocb) {
.ki_filp = filp,
.ki_flags = iocb_flags(filp),
};
}
/*
* "descriptor" for what we're up to with a read.
* This allows us to use the same read code yet
* have multiple different users of the data that
* we read from a file.
*
* The simplest case just copies the data to user
* mode.
*/
typedef struct {
size_t written;
size_t count;
union {
char __user *buf;
void *data;
} arg;
int error;
} read_descriptor_t;
typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
unsigned long, unsigned long);
struct address_space_operations {
int (*writepage)(struct page *page, struct writeback_control *wbc);
int (*readpage)(struct file *, struct page *);
/* Write back some dirty pages from this mapping. */
int (*writepages)(struct address_space *, struct writeback_control *);
/* Set a page dirty. Return true if this dirtied it */
int (*set_page_dirty)(struct page *page);
int (*readpages)(struct file *filp, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages);
int (*write_begin)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
int (*write_end)(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
sector_t (*bmap)(struct address_space *, sector_t);
void (*invalidatepage) (struct page *, unsigned int, unsigned int);
int (*releasepage) (struct page *, gfp_t);
void (*freepage)(struct page *);
ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset);
/*
* migrate the contents of a page to the specified target. If
* migrate_mode is MIGRATE_ASYNC, it must not block.
*/
int (*migratepage) (struct address_space *,
struct page *, struct page *, enum migrate_mode);
int (*launder_page) (struct page *);
int (*is_partially_uptodate) (struct page *, unsigned long,
unsigned long);
void (*is_dirty_writeback) (struct page *, bool *, bool *);
int (*error_remove_page)(struct address_space *, struct page *);
/* swapfile support */
int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
sector_t *span);
void (*swap_deactivate)(struct file *file);
};
extern const struct address_space_operations empty_aops;
/*
* pagecache_write_begin/pagecache_write_end must be used by general code
* to write into the pagecache.
*/
int pagecache_write_begin(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
int pagecache_write_end(struct file *, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
struct address_space {
struct inode *host; /* owner: inode, block_device */
struct radix_tree_root page_tree; /* radix tree of all pages */
spinlock_t tree_lock; /* and lock protecting it */
atomic_t i_mmap_writable;/* count VM_SHARED mappings */
struct rb_root i_mmap; /* tree of private and shared mappings */
struct rw_semaphore i_mmap_rwsem; /* protect tree, count, list */
/* Protected by tree_lock together with the radix tree */
unsigned long nrpages; /* number of total pages */
unsigned long nrshadows; /* number of shadow entries */
pgoff_t writeback_index;/* writeback starts here */
const struct address_space_operations *a_ops; /* methods */
unsigned long flags; /* error bits/gfp mask */
spinlock_t private_lock; /* for use by the address_space */
struct list_head private_list; /* ditto */
void *private_data; /* ditto */
} __attribute__((aligned(sizeof(long))));
/*
* On most architectures that alignment is already the case; but
* must be enforced here for CRIS, to let the least significant bit
* of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
*/
struct request_queue;
struct block_device {
dev_t bd_dev; /* not a kdev_t - it's a search key */
int bd_openers;
struct inode * bd_inode; /* will die */
struct super_block * bd_super;
struct mutex bd_mutex; /* open/close mutex */
struct list_head bd_inodes;
void * bd_claiming;
void * bd_holder;
int bd_holders;
bool bd_write_holder;
#ifdef CONFIG_SYSFS
struct list_head bd_holder_disks;
#endif
struct block_device * bd_contains;
unsigned bd_block_size;
struct hd_struct * bd_part;
/* number of times partitions within this device have been opened. */
unsigned bd_part_count;
int bd_invalidated;
struct gendisk * bd_disk;
struct request_queue * bd_queue;
struct list_head bd_list;
/*
* Private data. You must have bd_claim'ed the block_device
* to use this. NOTE: bd_claim allows an owner to claim
* the same device multiple times, the owner must take special
* care to not mess up bd_private for that case.
*/
unsigned long bd_private;
/* The counter of freeze processes */
int bd_fsfreeze_count;
/* Mutex for freeze */
struct mutex bd_fsfreeze_mutex;
};
/*
* Radix-tree tags, for tagging dirty and writeback pages within the pagecache
* radix trees
*/
#define PAGECACHE_TAG_DIRTY 0
#define PAGECACHE_TAG_WRITEBACK 1
#define PAGECACHE_TAG_TOWRITE 2
int mapping_tagged(struct address_space *mapping, int tag);
static inline void i_mmap_lock_write(struct address_space *mapping)
{
down_write(&mapping->i_mmap_rwsem);
}
static inline void i_mmap_unlock_write(struct address_space *mapping)
{
up_write(&mapping->i_mmap_rwsem);
}
static inline void i_mmap_lock_read(struct address_space *mapping)
{
down_read(&mapping->i_mmap_rwsem);
}
static inline void i_mmap_unlock_read(struct address_space *mapping)
{
up_read(&mapping->i_mmap_rwsem);
}
/*
* Might pages of this file be mapped into userspace?
*/
static inline int mapping_mapped(struct address_space *mapping)
{
return !RB_EMPTY_ROOT(&mapping->i_mmap);
}
/*
* Might pages of this file have been modified in userspace?
* Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
* marks vma as VM_SHARED if it is shared, and the file was opened for
* writing i.e. vma may be mprotected writable even if now readonly.
*
* If i_mmap_writable is negative, no new writable mappings are allowed. You
* can only deny writable mappings, if none exists right now.
*/
static inline int mapping_writably_mapped(struct address_space *mapping)
{
return atomic_read(&mapping->i_mmap_writable) > 0;
}
static inline int mapping_map_writable(struct address_space *mapping)
{
return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
0 : -EPERM;
}
static inline void mapping_unmap_writable(struct address_space *mapping)
{
atomic_dec(&mapping->i_mmap_writable);
}
static inline int mapping_deny_writable(struct address_space *mapping)
{
return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
0 : -EBUSY;
}
static inline void mapping_allow_writable(struct address_space *mapping)
{
atomic_inc(&mapping->i_mmap_writable);
}
/*
* Use sequence counter to get consistent i_size on 32-bit processors.
*/
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
#include <linux/seqlock.h>
#define __NEED_I_SIZE_ORDERED
#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
#else
#define i_size_ordered_init(inode) do { } while (0)
#endif
struct posix_acl;
#define ACL_NOT_CACHED ((void *)(-1))
#define IOP_FASTPERM 0x0001
#define IOP_LOOKUP 0x0002
#define IOP_NOFOLLOW 0x0004
/*
* Keep mostly read-only and often accessed (especially for
* the RCU path lookup and 'stat' data) fields at the beginning
* of the 'struct inode'
*/
struct inode {
umode_t i_mode;
unsigned short i_opflags;
kuid_t i_uid;
kgid_t i_gid;
unsigned int i_flags;
#ifdef CONFIG_FS_POSIX_ACL
struct posix_acl *i_acl;
struct posix_acl *i_default_acl;
#endif
const struct inode_operations *i_op;
struct super_block *i_sb;
struct address_space *i_mapping;
#ifdef CONFIG_SECURITY
void *i_security;
#endif
/* Stat data, not accessed from path walking */
unsigned long i_ino;
/*
* Filesystems may only read i_nlink directly. They shall use the
* following functions for modification:
*
* (set|clear|inc|drop)_nlink
* inode_(inc|dec)_link_count
*/
union {
const unsigned int i_nlink;
unsigned int __i_nlink;
};
dev_t i_rdev;
loff_t i_size;
struct timespec i_atime;
struct timespec i_mtime;
struct timespec i_ctime;
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
unsigned short i_bytes;
unsigned int i_blkbits;
blkcnt_t i_blocks;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
/* Misc */
unsigned long i_state;
struct mutex i_mutex;
unsigned long dirtied_when; /* jiffies of first dirtying */
unsigned long dirtied_time_when;
struct hlist_node i_hash;
struct list_head i_wb_list; /* backing dev IO list */
#ifdef CONFIG_CGROUP_WRITEBACK
struct bdi_writeback *i_wb; /* the associated cgroup wb */
/* foreign inode detection, see wbc_detach_inode() */
int i_wb_frn_winner;
u16 i_wb_frn_avg_time;
u16 i_wb_frn_history;
#endif
struct list_head i_lru; /* inode LRU list */
struct list_head i_sb_list;
union {
struct hlist_head i_dentry;
struct rcu_head i_rcu;
};
u64 i_version;
atomic_t i_count;
atomic_t i_dio_count;
atomic_t i_writecount;
#ifdef CONFIG_IMA
atomic_t i_readcount; /* struct files open RO */
#endif
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
struct file_lock_context *i_flctx;
struct address_space i_data;
struct list_head i_devices;
union {
struct pipe_inode_info *i_pipe;
struct block_device *i_bdev;
struct cdev *i_cdev;
char *i_link;
};
__u32 i_generation;
#ifdef CONFIG_FSNOTIFY
__u32 i_fsnotify_mask; /* all events this inode cares about */
struct hlist_head i_fsnotify_marks;
#endif
void *i_private; /* fs or device private pointer */
};
static inline int inode_unhashed(struct inode *inode)
{
return hlist_unhashed(&inode->i_hash);
}
/*
* inode->i_mutex nesting subclasses for the lock validator:
*
* 0: the object of the current VFS operation
* 1: parent
* 2: child/target
* 3: xattr
* 4: second non-directory
* 5: second parent (when locking independent directories in rename)
*
* I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
* non-directories at once.
*
* The locking order between these classes is
* parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
*/
enum inode_i_mutex_lock_class
{
I_MUTEX_NORMAL,
I_MUTEX_PARENT,
I_MUTEX_CHILD,
I_MUTEX_XATTR,
I_MUTEX_NONDIR2,
I_MUTEX_PARENT2,
};
void lock_two_nondirectories(struct inode *, struct inode*);
void unlock_two_nondirectories(struct inode *, struct inode*);
/*
* NOTE: in a 32bit arch with a preemptable kernel and
* an UP compile the i_size_read/write must be atomic
* with respect to the local cpu (unlike with preempt disabled),
* but they don't need to be atomic with respect to other cpus like in
* true SMP (so they need either to either locally disable irq around
* the read or for example on x86 they can be still implemented as a
* cmpxchg8b without the need of the lock prefix). For SMP compiles
* and 64bit archs it makes no difference if preempt is enabled or not.
*/
static inline loff_t i_size_read(const struct inode *inode)
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
loff_t i_size;
unsigned int seq;
do {
seq = read_seqcount_begin(&inode->i_size_seqcount);
i_size = inode->i_size;
} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
return i_size;
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
loff_t i_size;
preempt_disable();
i_size = inode->i_size;
preempt_enable();
return i_size;
#else
return inode->i_size;
#endif
}
/*
* NOTE: unlike i_size_read(), i_size_write() does need locking around it
* (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
* can be lost, resulting in subsequent i_size_read() calls spinning forever.
*/
static inline void i_size_write(struct inode *inode, loff_t i_size)
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
preempt_disable();
write_seqcount_begin(&inode->i_size_seqcount);
inode->i_size = i_size;
write_seqcount_end(&inode->i_size_seqcount);
preempt_enable();
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
preempt_disable();
inode->i_size = i_size;
preempt_enable();
#else
inode->i_size = i_size;
#endif
}
/* Helper functions so that in most cases filesystems will
* not need to deal directly with kuid_t and kgid_t and can
* instead deal with the raw numeric values that are stored
* in the filesystem.
*/
static inline uid_t i_uid_read(const struct inode *inode)
{
return from_kuid(&init_user_ns, inode->i_uid);
}
static inline gid_t i_gid_read(const struct inode *inode)
{
return from_kgid(&init_user_ns, inode->i_gid);
}
static inline void i_uid_write(struct inode *inode, uid_t uid)
{
inode->i_uid = make_kuid(&init_user_ns, uid);
}
static inline void i_gid_write(struct inode *inode, gid_t gid)
{
inode->i_gid = make_kgid(&init_user_ns, gid);
}
static inline unsigned iminor(const struct inode *inode)
{
return MINOR(inode->i_rdev);
}
static inline unsigned imajor(const struct inode *inode)
{
return MAJOR(inode->i_rdev);
}
extern struct block_device *I_BDEV(struct inode *inode);
struct fown_struct {
rwlock_t lock; /* protects pid, uid, euid fields */
struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
kuid_t uid, euid; /* uid/euid of process setting the owner */
int signum; /* posix.1b rt signal to be delivered on IO */
};
/*
* Track a single file's readahead state
*/
struct file_ra_state {
pgoff_t start; /* where readahead started */
unsigned int size; /* # of readahead pages */
unsigned int async_size; /* do asynchronous readahead when
there are only # of pages ahead */
unsigned int ra_pages; /* Maximum readahead window */
unsigned int mmap_miss; /* Cache miss stat for mmap accesses */
loff_t prev_pos; /* Cache last read() position */
};
/*
* Check if @index falls in the readahead windows.
*/
static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
{
return (index >= ra->start &&
index < ra->start + ra->size);
}
struct file {
union {
struct llist_node fu_llist;
struct rcu_head fu_rcuhead;
} f_u;
struct path f_path;
struct inode *f_inode; /* cached value */
const struct file_operations *f_op;
/*
* Protects f_ep_links, f_flags.
* Must not be taken from IRQ context.
*/
spinlock_t f_lock;
atomic_long_t f_count;
unsigned int f_flags;
fmode_t f_mode;
struct mutex f_pos_lock;
loff_t f_pos;
struct fown_struct f_owner;
const struct cred *f_cred;
struct file_ra_state f_ra;
u64 f_version;
#ifdef CONFIG_SECURITY
void *f_security;
#endif
/* needed for tty driver, and maybe others */
void *private_data;
#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
struct list_head f_tfile_llink;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space *f_mapping;
} __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
struct file_handle {
__u32 handle_bytes;
int handle_type;
/* file identifier */
unsigned char f_handle[0];
};
static inline struct file *get_file(struct file *f)
{
atomic_long_inc(&f->f_count);
return f;
}
#define get_file_rcu(x) atomic_long_inc_not_zero(&(x)->f_count)
#define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1)
#define file_count(x) atomic_long_read(&(x)->f_count)
#define MAX_NON_LFS ((1UL<<31) - 1)
/* Page cache limit. The filesystems should put that into their s_maxbytes
limits, otherwise bad things can happen in VM. */
#if BITS_PER_LONG==32
#define MAX_LFS_FILESIZE (((loff_t)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
#elif BITS_PER_LONG==64
#define MAX_LFS_FILESIZE ((loff_t)0x7fffffffffffffffLL)
#endif
#define FL_POSIX 1
#define FL_FLOCK 2
#define FL_DELEG 4 /* NFSv4 delegation */
#define FL_ACCESS 8 /* not trying to lock, just looking */
#define FL_EXISTS 16 /* when unlocking, test for existence */
#define FL_LEASE 32 /* lease held on this file */
#define FL_CLOSE 64 /* unlock on close */
#define FL_SLEEP 128 /* A blocking lock */
#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */
#define FL_UNLOCK_PENDING 512 /* Lease is being broken */
#define FL_OFDLCK 1024 /* lock is "owned" by struct file */
#define FL_LAYOUT 2048 /* outstanding pNFS layout */
/*
* Special return value from posix_lock_file() and vfs_lock_file() for
* asynchronous locking.
*/
#define FILE_LOCK_DEFERRED 1
/* legacy typedef, should eventually be removed */
typedef void *fl_owner_t;
struct file_lock;
struct file_lock_operations {
void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
void (*fl_release_private)(struct file_lock *);
};
struct lock_manager_operations {
int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
unsigned long (*lm_owner_key)(struct file_lock *);
fl_owner_t (*lm_get_owner)(fl_owner_t);
void (*lm_put_owner)(fl_owner_t);
void (*lm_notify)(struct file_lock *); /* unblock callback */
int (*lm_grant)(struct file_lock *, int);
bool (*lm_break)(struct file_lock *);
int (*lm_change)(struct file_lock *, int, struct list_head *);
void (*lm_setup)(struct file_lock *, void **);
};
struct lock_manager {
struct list_head list;
};
struct net;
void locks_start_grace(struct net *, struct lock_manager *);
void locks_end_grace(struct lock_manager *);
int locks_in_grace(struct net *);
/* that will die - we need it for nfs_lock_info */
#include <linux/nfs_fs_i.h>
/*
* struct file_lock represents a generic "file lock". It's used to represent
* POSIX byte range locks, BSD (flock) locks, and leases. It's important to
* note that the same struct is used to represent both a request for a lock and
* the lock itself, but the same object is never used for both.
*
* FIXME: should we create a separate "struct lock_request" to help distinguish
* these two uses?
*
* The varous i_flctx lists are ordered by:
*
* 1) lock owner
* 2) lock range start
* 3) lock range end
*
* Obviously, the last two criteria only matter for POSIX locks.
*/
struct file_lock {
struct file_lock *fl_next; /* singly linked list for this inode */
struct list_head fl_list; /* link into file_lock_context */
struct hlist_node fl_link; /* node in global lists */
struct list_head fl_block; /* circular list of blocked processes */
fl_owner_t fl_owner;
unsigned int fl_flags;
unsigned char fl_type;
unsigned int fl_pid;
int fl_link_cpu; /* what cpu's list is this on? */
struct pid *fl_nspid;
wait_queue_head_t fl_wait;
struct file *fl_file;
loff_t fl_start;
loff_t fl_end;
struct fasync_struct * fl_fasync; /* for lease break notifications */
/* for lease breaks: */
unsigned long fl_break_time;
unsigned long fl_downgrade_time;
const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
union {
struct nfs_lock_info nfs_fl;
struct nfs4_lock_info nfs4_fl;
struct {
struct list_head link; /* link in AFS vnode's pending_locks list */
int state; /* state of grant or error if -ve */
} afs;
} fl_u;
};
struct file_lock_context {
spinlock_t flc_lock;
struct list_head flc_flock;
struct list_head flc_posix;
struct list_head flc_lease;
};
/* The following constant reflects the upper bound of the file/locking space */
#ifndef OFFSET_MAX
#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
#define OFFSET_MAX INT_LIMIT(loff_t)
#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
#endif
#include <linux/fcntl.h>
extern void send_sigio(struct fown_struct *fown, int fd, int band);
#ifdef CONFIG_FILE_LOCKING
extern int fcntl_getlk(struct file *, unsigned int, struct flock __user *);
extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
struct flock __user *);
#if BITS_PER_LONG == 32
extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 __user *);
extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
struct flock64 __user *);
#endif
extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
extern int fcntl_getlease(struct file *filp);
/* fs/locks.c */
void locks_free_lock_context(struct file_lock_context *ctx);
void locks_free_lock(struct file_lock *fl);
extern void locks_init_lock(struct file_lock *);
extern struct file_lock * locks_alloc_lock(void);
extern void locks_copy_lock(struct file_lock *, struct file_lock *);
extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
extern void locks_remove_posix(struct file *, fl_owner_t);
extern void locks_remove_file(struct file *);
extern void locks_release_private(struct file_lock *);
extern void posix_test_lock(struct file *, struct file_lock *);
extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
extern int posix_lock_inode_wait(struct inode *, struct file_lock *);
extern int posix_unblock_lock(struct file_lock *);
extern int vfs_test_lock(struct file *, struct file_lock *);
extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
extern int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl);
extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
extern void lease_get_mtime(struct inode *, struct timespec *time);
extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
extern int lease_modify(struct file_lock *, int, struct list_head *);
struct files_struct;
extern void show_fd_locks(struct seq_file *f,
struct file *filp, struct files_struct *files);
#else /* !CONFIG_FILE_LOCKING */
static inline int fcntl_getlk(struct file *file, unsigned int cmd,
struct flock __user *user)
{
return -EINVAL;
}
static inline int fcntl_setlk(unsigned int fd, struct file *file,
unsigned int cmd, struct flock __user *user)
{
return -EACCES;
}
#if BITS_PER_LONG == 32
static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
struct flock64 __user *user)
{
return -EINVAL;
}
static inline int fcntl_setlk64(unsigned int fd, struct file *file,
unsigned int cmd, struct flock64 __user *user)
{
return -EACCES;
}
#endif
static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
{
return -EINVAL;
}
static inline int fcntl_getlease(struct file *filp)
{
return F_UNLCK;
}
static inline void
locks_free_lock_context(struct file_lock_context *ctx)
{
}
static inline void locks_init_lock(struct file_lock *fl)
{
return;
}
static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
{
return;
}
static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
{
return;
}
static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
{
return;
}
static inline void locks_remove_file(struct file *filp)
{
return;
}
static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
{
return;
}
static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
struct file_lock *conflock)
{
return -ENOLCK;
}
static inline int posix_lock_inode_wait(struct inode *inode,
struct file_lock *fl)
{
return -ENOLCK;
}
static inline int posix_unblock_lock(struct file_lock *waiter)
{
return -ENOENT;
}
static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
{
return 0;
}
static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
struct file_lock *fl, struct file_lock *conf)
{
return -ENOLCK;
}
static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
{
return 0;
}
static inline int flock_lock_inode_wait(struct inode *inode,
struct file_lock *request)
{
return -ENOLCK;
}
static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
{
return 0;
}
static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
{
return;
}
static inline int generic_setlease(struct file *filp, long arg,
struct file_lock **flp, void **priv)
{
return -EINVAL;
}
static inline int vfs_setlease(struct file *filp, long arg,
struct file_lock **lease, void **priv)
{
return -EINVAL;
}
static inline int lease_modify(struct file_lock *fl, int arg,
struct list_head *dispose)
{
return -EINVAL;
}
struct files_struct;
static inline void show_fd_locks(struct seq_file *f,
struct file *filp, struct files_struct *files) {}
#endif /* !CONFIG_FILE_LOCKING */
static inline struct inode *file_inode(const struct file *f)
{
return f->f_inode;
}
static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
{
return posix_lock_inode_wait(file_inode(filp), fl);
}
static inline int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
{
return flock_lock_inode_wait(file_inode(filp), fl);
}
struct fasync_struct {
spinlock_t fa_lock;
int magic;
int fa_fd;
struct fasync_struct *fa_next; /* singly linked list */
struct file *fa_file;
struct rcu_head fa_rcu;
};
#define FASYNC_MAGIC 0x4601
/* SMP safe fasync helpers: */
extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
extern int fasync_remove_entry(struct file *, struct fasync_struct **);
extern struct fasync_struct *fasync_alloc(void);
extern void fasync_free(struct fasync_struct *);
/* can be called from interrupts */
extern void kill_fasync(struct fasync_struct **, int, int);
extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
extern void f_setown(struct file *filp, unsigned long arg, int force);
extern void f_delown(struct file *filp);
extern pid_t f_getown(struct file *filp);
extern int send_sigurg(struct fown_struct *fown);
struct mm_struct;
/*
* Umount options
*/
#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
#define MNT_DETACH 0x00000002 /* Just detach from the tree */
#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
/* sb->s_iflags */
#define SB_I_CGROUPWB 0x00000001 /* cgroup-aware writeback enabled */
#define SB_I_NOEXEC 0x00000002 /* Ignore executables on this fs */
/* Possible states of 'frozen' field */
enum {
SB_UNFROZEN = 0, /* FS is unfrozen */
SB_FREEZE_WRITE = 1, /* Writes, dir ops, ioctls frozen */
SB_FREEZE_PAGEFAULT = 2, /* Page faults stopped as well */
SB_FREEZE_FS = 3, /* For internal FS use (e.g. to stop
* internal threads if needed) */
SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */
};
#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
struct sb_writers {
/* Counters for counting writers at each level */
struct percpu_counter counter[SB_FREEZE_LEVELS];
wait_queue_head_t wait; /* queue for waiting for
writers / faults to finish */
int frozen; /* Is sb frozen? */
wait_queue_head_t wait_unfrozen; /* queue for waiting for
sb to be thawed */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map lock_map[SB_FREEZE_LEVELS];
#endif
};
struct super_block {
struct list_head s_list; /* Keep this first */
dev_t s_dev; /* search index; _not_ kdev_t */
unsigned char s_blocksize_bits;
unsigned long s_blocksize;
loff_t s_maxbytes; /* Max file size */
struct file_system_type *s_type;
const struct super_operations *s_op;
const struct dquot_operations *dq_op;
const struct quotactl_ops *s_qcop;
const struct export_operations *s_export_op;
unsigned long s_flags;
unsigned long s_iflags; /* internal SB_I_* flags */
unsigned long s_magic;
struct dentry *s_root;
struct rw_semaphore s_umount;
int s_count;
atomic_t s_active;
#ifdef CONFIG_SECURITY
void *s_security;
#endif
const struct xattr_handler **s_xattr;
struct list_head s_inodes; /* all inodes */
struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
struct list_head s_mounts; /* list of mounts; _not_ for fs use */
struct block_device *s_bdev;
struct backing_dev_info *s_bdi;
struct mtd_info *s_mtd;
struct hlist_node s_instances;
unsigned int s_quota_types; /* Bitmask of supported quota types */
struct quota_info s_dquot; /* Diskquota specific options */
struct sb_writers s_writers;
char s_id[32]; /* Informational name */
u8 s_uuid[16]; /* UUID */
void *s_fs_info; /* Filesystem private info */
unsigned int s_max_links;
fmode_t s_mode;
/* Granularity of c/m/atime in ns.
Cannot be worse than a second */
u32 s_time_gran;
/*
* The next field is for VFS *only*. No filesystems have any business
* even looking at it. You had been warned.
*/
struct mutex s_vfs_rename_mutex; /* Kludge */
/*
* Filesystem subtype. If non-empty the filesystem type field
* in /proc/mounts will be "type.subtype"
*/
char *s_subtype;
/*
* Saved mount options for lazy filesystems using
* generic_show_options()
*/
char __rcu *s_options;
const struct dentry_operations *s_d_op; /* default d_op for dentries */
/*
* Saved pool identifier for cleancache (-1 means none)
*/
int cleancache_poolid;
struct shrinker s_shrink; /* per-sb shrinker handle */
/* Number of inodes with nlink == 0 but still referenced */
atomic_long_t s_remove_count;
/* Being remounted read-only */
int s_readonly_remount;
/* AIO completions deferred from interrupt context */
struct workqueue_struct *s_dio_done_wq;
struct hlist_head s_pins;
/*
* Keep the lru lists last in the structure so they always sit on their
* own individual cachelines.
*/
struct list_lru s_dentry_lru ____cacheline_aligned_in_smp;
struct list_lru s_inode_lru ____cacheline_aligned_in_smp;
struct rcu_head rcu;
/*
* Indicates how deep in a filesystem stack this SB is
*/
int s_stack_depth;
};
extern struct timespec current_fs_time(struct super_block *sb);
/*
* Snapshotting support.
*/
void __sb_end_write(struct super_block *sb, int level);
int __sb_start_write(struct super_block *sb, int level, bool wait);
/**
* sb_end_write - drop write access to a superblock
* @sb: the super we wrote to
*
* Decrement number of writers to the filesystem. Wake up possible waiters
* wanting to freeze the filesystem.
*/
static inline void sb_end_write(struct super_block *sb)
{
__sb_end_write(sb, SB_FREEZE_WRITE);
}
/**
* sb_end_pagefault - drop write access to a superblock from a page fault
* @sb: the super we wrote to
*
* Decrement number of processes handling write page fault to the filesystem.
* Wake up possible waiters wanting to freeze the filesystem.
*/
static inline void sb_end_pagefault(struct super_block *sb)
{
__sb_end_write(sb, SB_FREEZE_PAGEFAULT);
}
/**
* sb_end_intwrite - drop write access to a superblock for internal fs purposes
* @sb: the super we wrote to
*
* Decrement fs-internal number of writers to the filesystem. Wake up possible
* waiters wanting to freeze the filesystem.
*/
static inline void sb_end_intwrite(struct super_block *sb)
{
__sb_end_write(sb, SB_FREEZE_FS);
}
/**
* sb_start_write - get write access to a superblock
* @sb: the super we write to
*
* When a process wants to write data or metadata to a file system (i.e. dirty
* a page or an inode), it should embed the operation in a sb_start_write() -
* sb_end_write() pair to get exclusion against file system freezing. This
* function increments number of writers preventing freezing. If the file
* system is already frozen, the function waits until the file system is
* thawed.
*
* Since freeze protection behaves as a lock, users have to preserve
* ordering of freeze protection and other filesystem locks. Generally,
* freeze protection should be the outermost lock. In particular, we have:
*
* sb_start_write
* -> i_mutex (write path, truncate, directory ops, ...)
* -> s_umount (freeze_super, thaw_super)
*/
static inline void sb_start_write(struct super_block *sb)
{
__sb_start_write(sb, SB_FREEZE_WRITE, true);
}
static inline int sb_start_write_trylock(struct super_block *sb)
{
return __sb_start_write(sb, SB_FREEZE_WRITE, false);
}
/**
* sb_start_pagefault - get write access to a superblock from a page fault
* @sb: the super we write to
*
* When a process starts handling write page fault, it should embed the
* operation into sb_start_pagefault() - sb_end_pagefault() pair to get
* exclusion against file system freezing. This is needed since the page fault
* is going to dirty a page. This function increments number of running page
* faults preventing freezing. If the file system is already frozen, the
* function waits until the file system is thawed.
*
* Since page fault freeze protection behaves as a lock, users have to preserve
* ordering of freeze protection and other filesystem locks. It is advised to
* put sb_start_pagefault() close to mmap_sem in lock ordering. Page fault
* handling code implies lock dependency:
*
* mmap_sem
* -> sb_start_pagefault
*/
static inline void sb_start_pagefault(struct super_block *sb)
{
__sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
}
/*
* sb_start_intwrite - get write access to a superblock for internal fs purposes
* @sb: the super we write to
*
* This is the third level of protection against filesystem freezing. It is
* free for use by a filesystem. The only requirement is that it must rank
* below sb_start_pagefault.
*
* For example filesystem can call sb_start_intwrite() when starting a
* transaction which somewhat eases handling of freezing for internal sources
* of filesystem changes (internal fs threads, discarding preallocation on file
* close, etc.).
*/
static inline void sb_start_intwrite(struct super_block *sb)
{
__sb_start_write(sb, SB_FREEZE_FS, true);
}
extern bool inode_owner_or_capable(const struct inode *inode);
/*
* VFS helper functions..
*/
extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
extern int vfs_symlink(struct inode *, struct dentry *, const char *);
extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
extern int vfs_rmdir(struct inode *, struct dentry *);
extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
extern int vfs_whiteout(struct inode *, struct dentry *);
/*
* VFS dentry helper functions.
*/
extern void dentry_unhash(struct dentry *dentry);
/*
* VFS file helper functions.
*/
extern void inode_init_owner(struct inode *inode, const struct inode *dir,
umode_t mode);
/*
* VFS FS_IOC_FIEMAP helper definitions.
*/
struct fiemap_extent_info {
unsigned int fi_flags; /* Flags as passed from user */
unsigned int fi_extents_mapped; /* Number of mapped extents */
unsigned int fi_extents_max; /* Size of fiemap_extent array */
struct fiemap_extent __user *fi_extents_start; /* Start of
fiemap_extent array */
};
int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
u64 phys, u64 len, u32 flags);
int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
/*
* File types
*
* NOTE! These match bits 12..15 of stat.st_mode
* (ie "(i_mode >> 12) & 15").
*/
#define DT_UNKNOWN 0
#define DT_FIFO 1
#define DT_CHR 2
#define DT_DIR 4
#define DT_BLK 6
#define DT_REG 8
#define DT_LNK 10
#define DT_SOCK 12
#define DT_WHT 14
/*
* This is the "filldir" function type, used by readdir() to let
* the kernel specify what kind of dirent layout it wants to have.
* This allows the kernel to read directories into kernel space or
* to have different dirent layouts depending on the binary type.
*/
struct dir_context;
typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
unsigned);
struct dir_context {
const filldir_t actor;
loff_t pos;
};
struct block_device_operations;
/* These macros are for out of kernel modules to test that
* the kernel supports the unlocked_ioctl and compat_ioctl
* fields in struct file_operations. */
#define HAVE_COMPAT_IOCTL 1
#define HAVE_UNLOCKED_IOCTL 1
/*
* These flags let !MMU mmap() govern direct device mapping vs immediate
* copying more easily for MAP_PRIVATE, especially for ROM filesystems.
*
* NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE)
* NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED)
* NOMMU_MAP_READ: Can be mapped for reading
* NOMMU_MAP_WRITE: Can be mapped for writing
* NOMMU_MAP_EXEC: Can be mapped for execution
*/
#define NOMMU_MAP_COPY 0x00000001
#define NOMMU_MAP_DIRECT 0x00000008
#define NOMMU_MAP_READ VM_MAYREAD
#define NOMMU_MAP_WRITE VM_MAYWRITE
#define NOMMU_MAP_EXEC VM_MAYEXEC
#define NOMMU_VMFLAGS \
(NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
struct iov_iter;
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iterate) (struct file *, struct dir_context *);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*mremap)(struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **, void **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
unsigned (*mmap_capabilities)(struct file *);
#endif
};
struct inode_operations {
struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
const char * (*follow_link) (struct dentry *, void **);
int (*permission) (struct inode *, int);
struct posix_acl * (*get_acl)(struct inode *, int);
int (*readlink) (struct dentry *, char __user *,int);
void (*put_link) (struct inode *, void *);
int (*create) (struct inode *,struct dentry *, umode_t, bool);
int (*link) (struct dentry *,struct inode *,struct dentry *);
int (*unlink) (struct inode *,struct dentry *);
int (*symlink) (struct inode *,struct dentry *,const char *);
int (*mkdir) (struct inode *,struct dentry *,umode_t);
int (*rmdir) (struct inode *,struct dentry *);
int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
int (*rename) (struct inode *, struct dentry *,
struct inode *, struct dentry *);
int (*rename2) (struct inode *, struct dentry *,
struct inode *, struct dentry *, unsigned int);
int (*setattr) (struct dentry *, struct iattr *);
int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
ssize_t (*listxattr) (struct dentry *, char *, size_t);
int (*removexattr) (struct dentry *, const char *);
int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
u64 len);
int (*update_time)(struct inode *, struct timespec *, int);
int (*atomic_open)(struct inode *, struct dentry *,
struct file *, unsigned open_flag,
umode_t create_mode, int *opened);
int (*tmpfile) (struct inode *, struct dentry *, umode_t);
int (*set_acl)(struct inode *, struct posix_acl *, int);
/* WARNING: probably going away soon, do not use! */
} ____cacheline_aligned;
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer,
struct iovec **ret_pointer);
extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
extern ssize_t __vfs_write(struct file *, const char __user *, size_t, loff_t *);
extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
unsigned long, loff_t *);
extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
unsigned long, loff_t *);
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb);
void (*destroy_inode)(struct inode *);
void (*dirty_inode) (struct inode *, int flags);
int (*write_inode) (struct inode *, struct writeback_control *wbc);
int (*drop_inode) (struct inode *);
void (*evict_inode) (struct inode *);
void (*put_super) (struct super_block *);
int (*sync_fs)(struct super_block *sb, int wait);
int (*freeze_super) (struct super_block *);
int (*freeze_fs) (struct super_block *);
int (*thaw_super) (struct super_block *);
int (*unfreeze_fs) (struct super_block *);
int (*statfs) (struct dentry *, struct kstatfs *);
int (*remount_fs) (struct super_block *, int *, char *);
void (*umount_begin) (struct super_block *);
int (*show_options)(struct seq_file *, struct dentry *);
int (*show_devname)(struct seq_file *, struct dentry *);
int (*show_path)(struct seq_file *, struct dentry *);
int (*show_stats)(struct seq_file *, struct dentry *);
#ifdef CONFIG_QUOTA
ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
struct dquot **(*get_dquots)(struct inode *);
#endif
int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
long (*nr_cached_objects)(struct super_block *,
struct shrink_control *);
long (*free_cached_objects)(struct super_block *,
struct shrink_control *);
};
/*
* Inode flags - they have no relation to superblock flags now
*/
#define S_SYNC 1 /* Writes are synced at once */
#define S_NOATIME 2 /* Do not update access times */
#define S_APPEND 4 /* Append-only file */
#define S_IMMUTABLE 8 /* Immutable file */
#define S_DEAD 16 /* removed, but still open directory */
#define S_NOQUOTA 32 /* Inode is not counted to quota */
#define S_DIRSYNC 64 /* Directory modifications are synchronous */
#define S_NOCMTIME 128 /* Do not update file c/mtime */
#define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
#define S_PRIVATE 512 /* Inode is fs-internal */
#define S_IMA 1024 /* Inode has an associated IMA struct */
#define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */
#define S_NOSEC 4096 /* no suid or xattr security attributes */
#ifdef CONFIG_FS_DAX
#define S_DAX 8192 /* Direct Access, avoiding the page cache */
#else
#define S_DAX 0 /* Make all the DAX code disappear */
#endif
/*
* Note that nosuid etc flags are inode-specific: setting some file-system
* flags just means all the inodes inherit those flags by default. It might be
* possible to override it selectively if you really wanted to with some
* ioctl() that is not currently implemented.
*
* Exception: MS_RDONLY is always applied to the entire file system.
*
* Unfortunately, it is possible to change a filesystems flags with it mounted
* with files in use. This means that all of the inodes will not have their
* i_flags updated. Hence, i_flags no longer inherit the superblock mount
* flags, so these have to be checked separately. -- [email protected]
*/
#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
#define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \
((inode)->i_flags & S_SYNC))
#define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
#define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
#define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
#define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)
#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
#define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL)
#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
(inode)->i_rdev == WHITEOUT_DEV)
/*
* Inode state bits. Protected by inode->i_lock
*
* Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
* I_DIRTY_DATASYNC and I_DIRTY_PAGES.
*
* Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
* until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
* various stages of removing an inode.
*
* Two bits are used for locking and completion notification, I_NEW and I_SYNC.
*
* I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
* fdatasync(). i_atime is the usual cause.
* I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
* these changes separately from I_DIRTY_SYNC so that we
* don't have to write inode on fdatasync() when only
* mtime has changed in it.
* I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
* I_NEW Serves as both a mutex and completion notification.
* New inodes set I_NEW. If two processes both create
* the same inode, one of them will release its inode and
* wait for I_NEW to be released before returning.
* Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
* also cause waiting on I_NEW, without I_NEW actually
* being set. find_inode() uses this to prevent returning
* nearly-dead inodes.
* I_WILL_FREE Must be set when calling write_inode_now() if i_count
* is zero. I_FREEING must be set when I_WILL_FREE is
* cleared.
* I_FREEING Set when inode is about to be freed but still has dirty
* pages or buffers attached or the inode itself is still
* dirty.
* I_CLEAR Added by clear_inode(). In this state the inode is
* clean and can be destroyed. Inode keeps I_FREEING.
*
* Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
* prohibited for many purposes. iget() must wait for
* the inode to be completely released, then create it
* anew. Other functions will just ignore such inodes,
* if appropriate. I_NEW is used for waiting.
*
* I_SYNC Writeback of inode is running. The bit is set during
* data writeback, and cleared with a wakeup on the bit
* address once it is done. The bit is also used to pin
* the inode in memory for flusher thread.
*
* I_REFERENCED Marks the inode as recently references on the LRU list.
*
* I_DIO_WAKEUP Never set. Only used as a key for wait_on_bit().
*
* I_WB_SWITCH Cgroup bdi_writeback switching in progress. Used to
* synchronize competing switching instances and to tell
* wb stat updates to grab mapping->tree_lock. See
* inode_switch_wb_work_fn() for details.
*
* Q: What is the difference between I_WILL_FREE and I_FREEING?
*/
#define I_DIRTY_SYNC (1 << 0)
#define I_DIRTY_DATASYNC (1 << 1)
#define I_DIRTY_PAGES (1 << 2)
#define __I_NEW 3
#define I_NEW (1 << __I_NEW)
#define I_WILL_FREE (1 << 4)
#define I_FREEING (1 << 5)
#define I_CLEAR (1 << 6)
#define __I_SYNC 7
#define I_SYNC (1 << __I_SYNC)
#define I_REFERENCED (1 << 8)
#define __I_DIO_WAKEUP 9
#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
#define I_LINKABLE (1 << 10)
#define I_DIRTY_TIME (1 << 11)
#define __I_DIRTY_TIME_EXPIRED 12
#define I_DIRTY_TIME_EXPIRED (1 << __I_DIRTY_TIME_EXPIRED)
#define I_WB_SWITCH (1 << 13)
#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
extern void __mark_inode_dirty(struct inode *, int);
static inline void mark_inode_dirty(struct inode *inode)
{
__mark_inode_dirty(inode, I_DIRTY);
}
static inline void mark_inode_dirty_sync(struct inode *inode)
{
__mark_inode_dirty(inode, I_DIRTY_SYNC);
}
extern void inc_nlink(struct inode *inode);
extern void drop_nlink(struct inode *inode);
extern void clear_nlink(struct inode *inode);
extern void set_nlink(struct inode *inode, unsigned int nlink);
static inline void inode_inc_link_count(struct inode *inode)
{
inc_nlink(inode);
mark_inode_dirty(inode);
}
static inline void inode_dec_link_count(struct inode *inode)
{
drop_nlink(inode);
mark_inode_dirty(inode);
}
/**
* inode_inc_iversion - increments i_version
* @inode: inode that need to be updated
*
* Every time the inode is modified, the i_version field will be incremented.
* The filesystem has to be mounted with i_version flag
*/
static inline void inode_inc_iversion(struct inode *inode)
{
spin_lock(&inode->i_lock);
inode->i_version++;
spin_unlock(&inode->i_lock);
}
enum file_time_flags {
S_ATIME = 1,
S_MTIME = 2,
S_CTIME = 4,
S_VERSION = 8,
};
extern bool atime_needs_update(const struct path *, struct inode *);
extern void touch_atime(const struct path *);
static inline void file_accessed(struct file *file)
{
if (!(file->f_flags & O_NOATIME))
touch_atime(&file->f_path);
}
int sync_inode(struct inode *inode, struct writeback_control *wbc);
int sync_inode_metadata(struct inode *inode, int wait);
struct file_system_type {
const char *name;
int fs_flags;
#define FS_REQUIRES_DEV 1
#define FS_BINARY_MOUNTDATA 2
#define FS_HAS_SUBTYPE 4
#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
#define FS_USERNS_DEV_MOUNT 16 /* A userns mount does not imply MNT_NODEV */
#define FS_USERNS_VISIBLE 32 /* FS must already be visible */
#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
struct dentry *(*mount) (struct file_system_type *, int,
const char *, void *);
void (*kill_sb) (struct super_block *);
struct module *owner;
struct file_system_type * next;
struct hlist_head fs_supers;
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key;
struct lock_class_key s_vfs_rename_key;
struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
};
#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
void *data, int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_bdev(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_single(struct file_system_type *fs_type,
int flags, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_nodev(struct file_system_type *fs_type,
int flags, void *data,
int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
void generic_shutdown_super(struct super_block *sb);
void kill_block_super(struct super_block *sb);
void kill_anon_super(struct super_block *sb);
void kill_litter_super(struct super_block *sb);
void deactivate_super(struct super_block *sb);
void deactivate_locked_super(struct super_block *sb);
int set_anon_super(struct super_block *s, void *data);
int get_anon_bdev(dev_t *);
void free_anon_bdev(dev_t);
struct super_block *sget(struct file_system_type *type,
int (*test)(struct super_block *,void *),
int (*set)(struct super_block *,void *),
int flags, void *data);
extern struct dentry *mount_pseudo(struct file_system_type *, char *,
const struct super_operations *ops,
const struct dentry_operations *dops,
unsigned long);
/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
#define fops_get(fops) \
(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
#define fops_put(fops) \
do { if (fops) module_put((fops)->owner); } while(0)
/*
* This one is to be used *ONLY* from ->open() instances.
* fops must be non-NULL, pinned down *and* module dependencies
* should be sufficient to pin the caller down as well.
*/
#define replace_fops(f, fops) \
do { \
struct file *__file = (f); \
fops_put(__file->f_op); \
BUG_ON(!(__file->f_op = (fops))); \
} while(0)
extern int register_filesystem(struct file_system_type *);
extern int unregister_filesystem(struct file_system_type *);
extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
#define kern_mount(type) kern_mount_data(type, NULL)
extern void kern_unmount(struct vfsmount *mnt);
extern int may_umount_tree(struct vfsmount *);
extern int may_umount(struct vfsmount *);
extern long do_mount(const char *, const char __user *,
const char *, unsigned long, void *);
extern struct vfsmount *collect_mounts(struct path *);
extern void drop_collected_mounts(struct vfsmount *);
extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
struct vfsmount *);
extern int vfs_statfs(struct path *, struct kstatfs *);
extern int user_statfs(const char __user *, struct kstatfs *);
extern int fd_statfs(int, struct kstatfs *);
extern int vfs_ustat(dev_t, struct kstatfs *);
extern int freeze_super(struct super_block *super);
extern int thaw_super(struct super_block *super);
extern bool our_mnt(struct vfsmount *mnt);
extern int current_umask(void);
extern void ihold(struct inode * inode);
extern void iput(struct inode *);
extern int generic_update_time(struct inode *, struct timespec *, int);
/* /sys/fs */
extern struct kobject *fs_kobj;
#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
#define FLOCK_VERIFY_READ 1
#define FLOCK_VERIFY_WRITE 2
#ifdef CONFIG_FILE_LOCKING
extern int locks_mandatory_locked(struct file *);
extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
/*
* Candidates for mandatory locking have the setgid bit set
* but no group execute bit - an otherwise meaningless combination.
*/
static inline int __mandatory_lock(struct inode *ino)
{
return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
}
/*
* ... and these candidates should be on MS_MANDLOCK mounted fs,
* otherwise these will be advisory locks
*/
static inline int mandatory_lock(struct inode *ino)
{
return IS_MANDLOCK(ino) && __mandatory_lock(ino);
}
static inline int locks_verify_locked(struct file *file)
{
if (mandatory_lock(file_inode(file)))
return locks_mandatory_locked(file);
return 0;
}
static inline int locks_verify_truncate(struct inode *inode,
struct file *filp,
loff_t size)
{
if (inode->i_flctx && mandatory_lock(inode))
return locks_mandatory_area(
FLOCK_VERIFY_WRITE, inode, filp,
size < inode->i_size ? size : inode->i_size,
(size < inode->i_size ? inode->i_size - size
: size - inode->i_size)
);
return 0;
}
static inline int break_lease(struct inode *inode, unsigned int mode)
{
/*
* Since this check is lockless, we must ensure that any refcounts
* taken are done before checking i_flctx->flc_lease. Otherwise, we
* could end up racing with tasks trying to set a new lease on this
* file.
*/
smp_mb();
if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
return __break_lease(inode, mode, FL_LEASE);
return 0;
}
static inline int break_deleg(struct inode *inode, unsigned int mode)
{
/*
* Since this check is lockless, we must ensure that any refcounts
* taken are done before checking i_flctx->flc_lease. Otherwise, we
* could end up racing with tasks trying to set a new lease on this
* file.
*/
smp_mb();
if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
return __break_lease(inode, mode, FL_DELEG);
return 0;
}
static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
{
int ret;
ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
if (ret == -EWOULDBLOCK && delegated_inode) {
*delegated_inode = inode;
ihold(inode);
}
return ret;
}
static inline int break_deleg_wait(struct inode **delegated_inode)
{
int ret;
ret = break_deleg(*delegated_inode, O_WRONLY);
iput(*delegated_inode);
*delegated_inode = NULL;
return ret;
}
static inline int break_layout(struct inode *inode, bool wait)
{
smp_mb();
if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
return __break_lease(inode,
wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
FL_LAYOUT);
return 0;
}
#else /* !CONFIG_FILE_LOCKING */
static inline int locks_mandatory_locked(struct file *file)
{
return 0;
}
static inline int locks_mandatory_area(int rw, struct inode *inode,
struct file *filp, loff_t offset,
size_t count)
{
return 0;
}
static inline int __mandatory_lock(struct inode *inode)
{
return 0;
}
static inline int mandatory_lock(struct inode *inode)
{
return 0;
}
static inline int locks_verify_locked(struct file *file)
{
return 0;
}
static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
size_t size)
{
return 0;
}
static inline int break_lease(struct inode *inode, unsigned int mode)
{
return 0;
}
static inline int break_deleg(struct inode *inode, unsigned int mode)
{
return 0;
}
static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
{
return 0;
}
static inline int break_deleg_wait(struct inode **delegated_inode)
{
BUG();
return 0;
}
static inline int break_layout(struct inode *inode, bool wait)
{
return 0;
}
#endif /* CONFIG_FILE_LOCKING */
/* fs/open.c */
struct audit_names;
struct filename {
const char *name; /* pointer to actual string */
const __user char *uptr; /* original userland pointer */
struct audit_names *aname;
int refcnt;
const char iname[];
};
extern long vfs_truncate(struct path *, loff_t);
extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
struct file *filp);
extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
loff_t len);
extern long do_sys_open(int dfd, const char __user *filename, int flags,
umode_t mode);
extern struct file *file_open_name(struct filename *, int, umode_t);
extern struct file *filp_open(const char *, int, umode_t);
extern struct file *file_open_root(struct dentry *, struct vfsmount *,
const char *, int);
extern struct file * dentry_open(const struct path *, int, const struct cred *);
extern int filp_close(struct file *, fl_owner_t id);
extern struct filename *getname_flags(const char __user *, int, int *);
extern struct filename *getname(const char __user *);
extern struct filename *getname_kernel(const char *);
extern void putname(struct filename *name);
enum {
FILE_CREATED = 1,
FILE_OPENED = 2
};
extern int finish_open(struct file *file, struct dentry *dentry,
int (*open)(struct inode *, struct file *),
int *opened);
extern int finish_no_open(struct file *file, struct dentry *dentry);
/* fs/ioctl.c */
extern int ioctl_preallocate(struct file *filp, void __user *argp);
/* fs/dcache.c */
extern void __init vfs_caches_init_early(void);
extern void __init vfs_caches_init(void);
extern struct kmem_cache *names_cachep;
#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
#ifdef CONFIG_BLOCK
extern int register_blkdev(unsigned int, const char *);
extern void unregister_blkdev(unsigned int, const char *);
extern struct block_device *bdget(dev_t);
extern struct block_device *bdgrab(struct block_device *bdev);
extern void bd_set_size(struct block_device *, loff_t size);
extern void bd_forget(struct inode *inode);
extern void bdput(struct block_device *);
extern void invalidate_bdev(struct block_device *);
extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
extern int sync_blockdev(struct block_device *bdev);
extern void kill_bdev(struct block_device *);
extern struct super_block *freeze_bdev(struct block_device *);
extern void emergency_thaw_all(void);
extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
extern int fsync_bdev(struct block_device *);
extern struct super_block *blockdev_superblock;
static inline bool sb_is_blkdev_sb(struct super_block *sb)
{
return sb == blockdev_superblock;
}
#else
static inline void bd_forget(struct inode *inode) {}
static inline int sync_blockdev(struct block_device *bdev) { return 0; }
static inline void kill_bdev(struct block_device *bdev) {}
static inline void invalidate_bdev(struct block_device *bdev) {}
static inline struct super_block *freeze_bdev(struct block_device *sb)
{
return NULL;
}
static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
{
return 0;
}
static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg)
{
}
static inline int sb_is_blkdev_sb(struct super_block *sb)
{
return 0;
}
#endif
extern int sync_filesystem(struct super_block *);
extern const struct file_operations def_blk_fops;
extern const struct file_operations def_chr_fops;
#ifdef CONFIG_BLOCK
extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
void *holder);
extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
void *holder);
extern void blkdev_put(struct block_device *bdev, fmode_t mode);
extern int __blkdev_reread_part(struct block_device *bdev);
extern int blkdev_reread_part(struct block_device *bdev);
#ifdef CONFIG_SYSFS
extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
extern void bd_unlink_disk_holder(struct block_device *bdev,
struct gendisk *disk);
#else
static inline int bd_link_disk_holder(struct block_device *bdev,
struct gendisk *disk)
{
return 0;
}
static inline void bd_unlink_disk_holder(struct block_device *bdev,
struct gendisk *disk)
{
}
#endif
#endif
/* fs/char_dev.c */
#define CHRDEV_MAJOR_HASH_SIZE 255
extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
extern int register_chrdev_region(dev_t, unsigned, const char *);
extern int __register_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name,
const struct file_operations *fops);
extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name);
extern void unregister_chrdev_region(dev_t, unsigned);
extern void chrdev_show(struct seq_file *,off_t);
static inline int register_chrdev(unsigned int major, const char *name,
const struct file_operations *fops)
{
return __register_chrdev(major, 0, 256, name, fops);
}
static inline void unregister_chrdev(unsigned int major, const char *name)
{
__unregister_chrdev(major, 0, 256, name);
}
/* fs/block_dev.c */
#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
#define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */
#ifdef CONFIG_BLOCK
#define BLKDEV_MAJOR_HASH_SIZE 255
extern const char *__bdevname(dev_t, char *buffer);
extern const char *bdevname(struct block_device *bdev, char *buffer);
extern struct block_device *lookup_bdev(const char *);
extern void blkdev_show(struct seq_file *,off_t);
#else
#define BLKDEV_MAJOR_HASH_SIZE 0
#endif
extern void init_special_inode(struct inode *, umode_t, dev_t);
/* Invalid inode operations -- fs/bad_inode.c */
extern void make_bad_inode(struct inode *);
extern int is_bad_inode(struct inode *);
#ifdef CONFIG_BLOCK
/*
* return READ, READA, or WRITE
*/
#define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK))
/*
* return data direction, READ or WRITE
*/
#define bio_data_dir(bio) ((bio)->bi_rw & 1)
extern void check_disk_size_change(struct gendisk *disk,
struct block_device *bdev);
extern int revalidate_disk(struct gendisk *);
extern int check_disk_change(struct block_device *);
extern int __invalidate_device(struct block_device *, bool);
extern int invalidate_partition(struct gendisk *, int);
#endif
unsigned long invalidate_mapping_pages(struct address_space *mapping,
pgoff_t start, pgoff_t end);
static inline void invalidate_remote_inode(struct inode *inode)
{
if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
S_ISLNK(inode->i_mode))
invalidate_mapping_pages(inode->i_mapping, 0, -1);
}
extern int invalidate_inode_pages2(struct address_space *mapping);
extern int invalidate_inode_pages2_range(struct address_space *mapping,
pgoff_t start, pgoff_t end);
extern int write_inode_now(struct inode *, int);
extern int filemap_fdatawrite(struct address_space *);
extern int filemap_flush(struct address_space *);
extern int filemap_fdatawait(struct address_space *);
extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
loff_t lend);
extern int filemap_write_and_wait(struct address_space *mapping);
extern int filemap_write_and_wait_range(struct address_space *mapping,
loff_t lstart, loff_t lend);
extern int __filemap_fdatawrite_range(struct address_space *mapping,
loff_t start, loff_t end, int sync_mode);
extern int filemap_fdatawrite_range(struct address_space *mapping,
loff_t start, loff_t end);
extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
int datasync);
extern int vfs_fsync(struct file *file, int datasync);
static inline int generic_write_sync(struct file *file, loff_t pos, loff_t count)
{
if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))
return 0;
return vfs_fsync_range(file, pos, pos + count - 1,
(file->f_flags & __O_SYNC) ? 0 : 1);
}
extern void emergency_sync(void);
extern void emergency_remount(void);
#ifdef CONFIG_BLOCK
extern sector_t bmap(struct inode *, sector_t);
#endif
extern int notify_change(struct dentry *, struct iattr *, struct inode **);
extern int inode_permission(struct inode *, int);
extern int __inode_permission(struct inode *, int);
extern int generic_permission(struct inode *, int);
extern int __check_sticky(struct inode *dir, struct inode *inode);
static inline bool execute_ok(struct inode *inode)
{
return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
}
static inline void file_start_write(struct file *file)
{
if (!S_ISREG(file_inode(file)->i_mode))
return;
__sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
}
static inline bool file_start_write_trylock(struct file *file)
{
if (!S_ISREG(file_inode(file)->i_mode))
return true;
return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
}
static inline void file_end_write(struct file *file)
{
if (!S_ISREG(file_inode(file)->i_mode))
return;
__sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
}
/*
* get_write_access() gets write permission for a file.
* put_write_access() releases this write permission.
* This is used for regular files.
* We cannot support write (and maybe mmap read-write shared) accesses and
* MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
* can have the following values:
* 0: no writers, no VM_DENYWRITE mappings
* < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
* > 0: (i_writecount) users are writing to the file.
*
* Normally we operate on that counter with atomic_{inc,dec} and it's safe
* except for the cases where we don't hold i_writecount yet. Then we need to
* use {get,deny}_write_access() - these functions check the sign and refuse
* to do the change if sign is wrong.
*/
static inline int get_write_access(struct inode *inode)
{
return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
}
static inline int deny_write_access(struct file *file)
{
struct inode *inode = file_inode(file);
return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
}
static inline void put_write_access(struct inode * inode)
{
atomic_dec(&inode->i_writecount);
}
static inline void allow_write_access(struct file *file)
{
if (file)
atomic_inc(&file_inode(file)->i_writecount);
}
static inline bool inode_is_open_for_write(const struct inode *inode)
{
return atomic_read(&inode->i_writecount) > 0;
}
#ifdef CONFIG_IMA
static inline void i_readcount_dec(struct inode *inode)
{
BUG_ON(!atomic_read(&inode->i_readcount));
atomic_dec(&inode->i_readcount);
}
static inline void i_readcount_inc(struct inode *inode)
{
atomic_inc(&inode->i_readcount);
}
#else
static inline void i_readcount_dec(struct inode *inode)
{
return;
}
static inline void i_readcount_inc(struct inode *inode)
{
return;
}
#endif
extern int do_pipe_flags(int *, int);
extern int kernel_read(struct file *, loff_t, char *, unsigned long);
extern ssize_t kernel_write(struct file *, const char *, size_t, loff_t);
extern ssize_t __kernel_write(struct file *, const char *, size_t, loff_t *);
extern struct file * open_exec(const char *);
/* fs/dcache.c -- generic fs support functions */
extern int is_subdir(struct dentry *, struct dentry *);
extern int path_is_under(struct path *, struct path *);
extern char *file_path(struct file *, char *, int);
#include <linux/err.h>
/* needed for stackable file system support */
extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
extern int inode_init_always(struct super_block *, struct inode *);
extern void inode_init_once(struct inode *);
extern void address_space_init_once(struct address_space *mapping);
extern struct inode * igrab(struct inode *);
extern ino_t iunique(struct super_block *, ino_t);
extern int inode_needs_sync(struct inode *inode);
extern int generic_delete_inode(struct inode *inode);
static inline int generic_drop_inode(struct inode *inode)
{
return !inode->i_nlink || inode_unhashed(inode);
}
extern struct inode *ilookup5_nowait(struct super_block *sb,
unsigned long hashval, int (*test)(struct inode *, void *),
void *data);
extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
int (*test)(struct inode *, void *), void *data);
extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
extern struct inode * iget_locked(struct super_block *, unsigned long);
extern struct inode *find_inode_nowait(struct super_block *,
unsigned long,
int (*match)(struct inode *,
unsigned long, void *),
void *data);
extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
extern int insert_inode_locked(struct inode *);
#ifdef CONFIG_DEBUG_LOCK_ALLOC
extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
#else
static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
#endif
extern void unlock_new_inode(struct inode *);
extern unsigned int get_next_ino(void);
extern void __iget(struct inode * inode);
extern void iget_failed(struct inode *);
extern void clear_inode(struct inode *);
extern void __destroy_inode(struct inode *);
extern struct inode *new_inode_pseudo(struct super_block *sb);
extern struct inode *new_inode(struct super_block *sb);
extern void free_inode_nonrcu(struct inode *inode);
extern int should_remove_suid(struct dentry *);
extern int file_remove_privs(struct file *);
extern int dentry_needs_remove_privs(struct dentry *dentry);
static inline int file_needs_remove_privs(struct file *file)
{
return dentry_needs_remove_privs(file->f_path.dentry);
}
extern void __insert_inode_hash(struct inode *, unsigned long hashval);
static inline void insert_inode_hash(struct inode *inode)
{
__insert_inode_hash(inode, inode->i_ino);
}
extern void __remove_inode_hash(struct inode *);
static inline void remove_inode_hash(struct inode *inode)
{
if (!inode_unhashed(inode))
__remove_inode_hash(inode);
}
extern void inode_sb_list_add(struct inode *inode);
#ifdef CONFIG_BLOCK
extern void submit_bio(int, struct bio *);
extern int bdev_read_only(struct block_device *);
#endif
extern int set_blocksize(struct block_device *, int);
extern int sb_set_blocksize(struct super_block *, int);
extern int sb_min_blocksize(struct super_block *, int);
extern int generic_file_mmap(struct file *, struct vm_area_struct *);
extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *, loff_t);
extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos);
ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos);
/* fs/block_dev.c */
extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
int datasync);
extern void block_sync_page(struct page *page);
/* fs/splice.c */
extern ssize_t generic_file_splice_read(struct file *, loff_t *,
struct pipe_inode_info *, size_t, unsigned int);
extern ssize_t default_file_splice_read(struct file *, loff_t *,
struct pipe_inode_info *, size_t, unsigned int);
extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
struct file *, loff_t *, size_t, unsigned int);
extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
struct file *out, loff_t *, size_t len, unsigned int flags);
extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
loff_t *opos, size_t len, unsigned int flags);
extern void
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
int whence, loff_t maxsize, loff_t eof);
extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
int whence, loff_t size);
extern int generic_file_open(struct inode * inode, struct file * filp);
extern int nonseekable_open(struct inode * inode, struct file * filp);
ssize_t dax_do_io(struct kiocb *, struct inode *, struct iov_iter *, loff_t,
get_block_t, dio_iodone_t, int flags);
int dax_clear_blocks(struct inode *, sector_t block, long size);
int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t);
int dax_truncate_page(struct inode *, loff_t from, get_block_t);
int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
dax_iodone_t);
int __dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
dax_iodone_t);
int dax_pfn_mkwrite(struct vm_area_struct *, struct vm_fault *);
#define dax_mkwrite(vma, vmf, gb, iod) dax_fault(vma, vmf, gb, iod)
#define __dax_mkwrite(vma, vmf, gb, iod) __dax_fault(vma, vmf, gb, iod)
#ifdef CONFIG_BLOCK
typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
loff_t file_offset);
enum {
/* need locking between buffered and direct access */
DIO_LOCKING = 0x01,
/* filesystem does not support filling holes */
DIO_SKIP_HOLES = 0x02,
/* filesystem can handle aio writes beyond i_size */
DIO_ASYNC_EXTEND = 0x04,
/* inode/fs/bdev does not need truncate protection */
DIO_SKIP_DIO_COUNT = 0x08,
};
void dio_end_io(struct bio *bio, int error);
ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
struct block_device *bdev, struct iov_iter *iter,
loff_t offset, get_block_t get_block,
dio_iodone_t end_io, dio_submit_t submit_io,
int flags);
static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
struct inode *inode,
struct iov_iter *iter, loff_t offset,
get_block_t get_block)
{
return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
offset, get_block, NULL, NULL,
DIO_LOCKING | DIO_SKIP_HOLES);
}
#endif
void inode_dio_wait(struct inode *inode);
/*
* inode_dio_begin - signal start of a direct I/O requests
* @inode: inode the direct I/O happens on
*
* This is called once we've finished processing a direct I/O request,
* and is used to wake up callers waiting for direct I/O to be quiesced.
*/
static inline void inode_dio_begin(struct inode *inode)
{
atomic_inc(&inode->i_dio_count);
}
/*
* inode_dio_end - signal finish of a direct I/O requests
* @inode: inode the direct I/O happens on
*
* This is called once we've finished processing a direct I/O request,
* and is used to wake up callers waiting for direct I/O to be quiesced.
*/
static inline void inode_dio_end(struct inode *inode)
{
if (atomic_dec_and_test(&inode->i_dio_count))
wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
}
extern void inode_set_flags(struct inode *inode, unsigned int flags,
unsigned int mask);
extern const struct file_operations generic_ro_fops;
#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
extern int readlink_copy(char __user *, int, const char *);
extern int page_readlink(struct dentry *, char __user *, int);
extern const char *page_follow_link_light(struct dentry *, void **);
extern void page_put_link(struct inode *, void *);
extern int __page_symlink(struct inode *inode, const char *symname, int len,
int nofs);
extern int page_symlink(struct inode *inode, const char *symname, int len);
extern const struct inode_operations page_symlink_inode_operations;
extern void kfree_put_link(struct inode *, void *);
extern void free_page_put_link(struct inode *, void *);
extern int generic_readlink(struct dentry *, char __user *, int);
extern void generic_fillattr(struct inode *, struct kstat *);
int vfs_getattr_nosec(struct path *path, struct kstat *stat);
extern int vfs_getattr(struct path *, struct kstat *);
void __inode_add_bytes(struct inode *inode, loff_t bytes);
void inode_add_bytes(struct inode *inode, loff_t bytes);
void __inode_sub_bytes(struct inode *inode, loff_t bytes);
void inode_sub_bytes(struct inode *inode, loff_t bytes);
loff_t inode_get_bytes(struct inode *inode);
void inode_set_bytes(struct inode *inode, loff_t bytes);
const char *simple_follow_link(struct dentry *, void **);
extern const struct inode_operations simple_symlink_inode_operations;
extern int iterate_dir(struct file *, struct dir_context *);
extern int vfs_stat(const char __user *, struct kstat *);
extern int vfs_lstat(const char __user *, struct kstat *);
extern int vfs_fstat(unsigned int, struct kstat *);
extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
unsigned long arg);
extern int __generic_block_fiemap(struct inode *inode,
struct fiemap_extent_info *fieinfo,
loff_t start, loff_t len,
get_block_t *get_block);
extern int generic_block_fiemap(struct inode *inode,
struct fiemap_extent_info *fieinfo, u64 start,
u64 len, get_block_t *get_block);
extern void get_filesystem(struct file_system_type *fs);
extern void put_filesystem(struct file_system_type *fs);
extern struct file_system_type *get_fs_type(const char *name);
extern struct super_block *get_super(struct block_device *);
extern struct super_block *get_super_thawed(struct block_device *);
extern struct super_block *get_active_super(struct block_device *bdev);
extern void drop_super(struct super_block *sb);
extern void iterate_supers(void (*)(struct super_block *, void *), void *);
extern void iterate_supers_type(struct file_system_type *,
void (*)(struct super_block *, void *), void *);
extern int dcache_dir_open(struct inode *, struct file *);
extern int dcache_dir_close(struct inode *, struct file *);
extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
extern int dcache_readdir(struct file *, struct dir_context *);
extern int simple_setattr(struct dentry *, struct iattr *);
extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
extern int simple_statfs(struct dentry *, struct kstatfs *);
extern int simple_open(struct inode *inode, struct file *file);
extern int simple_link(struct dentry *, struct inode *, struct dentry *);
extern int simple_unlink(struct inode *, struct dentry *);
extern int simple_rmdir(struct inode *, struct dentry *);
extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
extern int noop_fsync(struct file *, loff_t, loff_t, int);
extern int simple_empty(struct dentry *);
extern int simple_readpage(struct file *file, struct page *page);
extern int simple_write_begin(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata);
extern int simple_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata);
extern int always_delete_dentry(const struct dentry *);
extern struct inode *alloc_anon_inode(struct super_block *);
extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
extern const struct dentry_operations simple_dentry_operations;
extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
extern const struct file_operations simple_dir_operations;
extern const struct inode_operations simple_dir_inode_operations;
extern void make_empty_dir_inode(struct inode *inode);
extern bool is_empty_dir_inode(struct inode *inode);
struct tree_descr { char *name; const struct file_operations *ops; int mode; };
struct dentry *d_alloc_name(struct dentry *, const char *);
extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
extern void simple_release_fs(struct vfsmount **mount, int *count);
extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
loff_t *ppos, const void *from, size_t available);
extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
const void __user *from, size_t count);
extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
extern int generic_check_addressable(unsigned, u64);
#ifdef CONFIG_MIGRATION
extern int buffer_migrate_page(struct address_space *,
struct page *, struct page *,
enum migrate_mode);
#else
#define buffer_migrate_page NULL
#endif
extern int inode_change_ok(const struct inode *, struct iattr *);
extern int inode_newsize_ok(const struct inode *, loff_t offset);
extern void setattr_copy(struct inode *inode, const struct iattr *attr);
extern int file_update_time(struct file *file);
extern int generic_show_options(struct seq_file *m, struct dentry *root);
extern void save_mount_options(struct super_block *sb, char *options);
extern void replace_mount_options(struct super_block *sb, char *options);
static inline bool io_is_direct(struct file *filp)
{
return (filp->f_flags & O_DIRECT) || IS_DAX(file_inode(filp));
}
static inline int iocb_flags(struct file *file)
{
int res = 0;
if (file->f_flags & O_APPEND)
res |= IOCB_APPEND;
if (io_is_direct(file))
res |= IOCB_DIRECT;
return res;
}
static inline ino_t parent_ino(struct dentry *dentry)
{
ino_t res;
/*
* Don't strictly need d_lock here? If the parent ino could change
* then surely we'd have a deeper race in the caller?
*/
spin_lock(&dentry->d_lock);
res = dentry->d_parent->d_inode->i_ino;
spin_unlock(&dentry->d_lock);
return res;
}
/* Transaction based IO helpers */
/*
* An argresp is stored in an allocated page and holds the
* size of the argument or response, along with its content
*/
struct simple_transaction_argresp {
ssize_t size;
char data[0];
};
#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
char *simple_transaction_get(struct file *file, const char __user *buf,
size_t size);
ssize_t simple_transaction_read(struct file *file, char __user *buf,
size_t size, loff_t *pos);
int simple_transaction_release(struct inode *inode, struct file *file);
void simple_transaction_set(struct file *file, size_t n);
/*
* simple attribute files
*
* These attributes behave similar to those in sysfs:
*
* Writing to an attribute immediately sets a value, an open file can be
* written to multiple times.
*
* Reading from an attribute creates a buffer from the value that might get
* read with multiple read calls. When the attribute has been read
* completely, no further read calls are possible until the file is opened
* again.
*
* All attributes contain a text representation of a numeric value
* that are accessed with the get() and set() functions.
*/
#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
static int __fops ## _open(struct inode *inode, struct file *file) \
{ \
__simple_attr_check_format(__fmt, 0ull); \
return simple_attr_open(inode, file, __get, __set, __fmt); \
} \
static const struct file_operations __fops = { \
.owner = THIS_MODULE, \
.open = __fops ## _open, \
.release = simple_attr_release, \
.read = simple_attr_read, \
.write = simple_attr_write, \
.llseek = generic_file_llseek, \
}
static inline __printf(1, 2)
void __simple_attr_check_format(const char *fmt, ...)
{
/* don't do anything, just let the compiler check the arguments; */
}
int simple_attr_open(struct inode *inode, struct file *file,
int (*get)(void *, u64 *), int (*set)(void *, u64),
const char *fmt);
int simple_attr_release(struct inode *inode, struct file *file);
ssize_t simple_attr_read(struct file *file, char __user *buf,
size_t len, loff_t *ppos);
ssize_t simple_attr_write(struct file *file, const char __user *buf,
size_t len, loff_t *ppos);
struct ctl_table;
int proc_nr_files(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int proc_nr_dentry(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int proc_nr_inodes(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos);
int __init get_filesystem_list(char *buf);
#define __FMODE_EXEC ((__force int) FMODE_EXEC)
#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
(flag & __FMODE_NONOTIFY)))
static inline int is_sxid(umode_t mode)
{
return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
}
static inline int check_sticky(struct inode *dir, struct inode *inode)
{
if (!(dir->i_mode & S_ISVTX))
return 0;
return __check_sticky(dir, inode);
}
static inline void inode_has_no_xattr(struct inode *inode)
{
if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC))
inode->i_flags |= S_NOSEC;
}
static inline bool is_root_inode(struct inode *inode)
{
return inode == inode->i_sb->s_root->d_inode;
}
static inline bool dir_emit(struct dir_context *ctx,
const char *name, int namelen,
u64 ino, unsigned type)
{
return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
}
static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
{
return ctx->actor(ctx, ".", 1, ctx->pos,
file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
}
static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
{
return ctx->actor(ctx, "..", 2, ctx->pos,
parent_ino(file->f_path.dentry), DT_DIR) == 0;
}
static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
{
if (ctx->pos == 0) {
if (!dir_emit_dot(file, ctx))
return false;
ctx->pos = 1;
}
if (ctx->pos == 1) {
if (!dir_emit_dotdot(file, ctx))
return false;
ctx->pos = 2;
}
return true;
}
static inline bool dir_relax(struct inode *inode)
{
mutex_unlock(&inode->i_mutex);
mutex_lock(&inode->i_mutex);
return !IS_DEADDIR(inode);
}
extern bool path_noexec(const struct path *path);
#endif /* _LINUX_FS_H */
| gpl-2.0 |
jpl888/coreboot | payloads/tianocoreboot/include/EfiTypes.h | 6770 | /*++
Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
EfiTypes.h
Abstract:
EFI defined types. Use these types when ever possible!
--*/
#ifndef _EFI_TYPES_H_
#define _EFI_TYPES_H_
//
// EFI Data Types based on ANSI C integer types in EfiBind.h
//
typedef uint8_t BOOLEAN;
typedef intn_t INTN;
typedef uintn_t UINTN;
typedef int8_t INT8;
typedef uint8_t UINT8;
typedef int16_t INT16;
typedef uint16_t UINT16;
typedef int32_t INT32;
typedef uint32_t UINT32;
typedef int64_t INT64;
typedef uint64_t UINT64;
typedef char CHAR8;
typedef uint16_t CHAR16;
typedef UINT64 EFI_LBA;
//
// Modifiers for EFI Data Types used to self document code.
// Please see EFI coding convention for proper usage.
//
#ifndef IN
//
// Some other envirnments use this construct, so #ifndef to prevent
// mulitple definition.
//
#define IN
#define OUT
#define OPTIONAL
#endif
#ifndef UNALIGNED
#define UNALIGNED
#endif
//
// Modifiers for EFI Runtime and Boot Services
//
#define EFI_RUNTIMESERVICE
#define EFI_BOOTSERVICE
//
// Boot Service add in EFI 1.1
//
#define EFI_BOOTSERVICE11
//
// Modifiers to absract standard types to aid in debug of problems
//
#define CONST const
#define STATIC static
#define VOID void
#define VOLATILE volatile
//
// Modifier to ensure that all protocol member functions and EFI intrinsics
// use the correct C calling convention. All protocol member functions and
// EFI intrinsics are required to modify thier member functions with EFIAPI.
//
#ifndef EFIAPI
#define EFIAPI _EFIAPI
#endif
//
// EFI Constants. They may exist in other build structures, so #ifndef them.
//
#ifndef TRUE
#define TRUE ((BOOLEAN) (1 == 1))
#endif
#ifndef FALSE
#define FALSE ((BOOLEAN) (0 == 1))
#endif
#ifndef NULL
#define NULL ((VOID *) 0)
#endif
//
// EFI Data Types derived from other EFI data types.
//
typedef UINTN EFI_STATUS;
typedef VOID *EFI_HANDLE;
#define NULL_HANDLE ((VOID *) 0)
typedef VOID *EFI_EVENT;
typedef UINTN EFI_TPL;
typedef struct {
UINT32 Data1;
UINT16 Data2;
UINT16 Data3;
UINT8 Data4[8];
} EFI_GUID;
typedef union {
EFI_GUID Guid;
UINT8 Raw[16];
} EFI_GUID_UNION;
//
// EFI Time Abstraction:
// Year: 2000 - 20XX
// Month: 1 - 12
// Day: 1 - 31
// Hour: 0 - 23
// Minute: 0 - 59
// Second: 0 - 59
// Nanosecond: 0 - 999,999,999
// TimeZone: -1440 to 1440 or 2047
//
typedef struct {
UINT16 Year;
UINT8 Month;
UINT8 Day;
UINT8 Hour;
UINT8 Minute;
UINT8 Second;
UINT8 Pad1;
UINT32 Nanosecond;
INT16 TimeZone;
UINT8 Daylight;
UINT8 Pad2;
} EFI_TIME;
//
// Bit definitions for EFI_TIME.Daylight
//
#define EFI_TIME_ADJUST_DAYLIGHT 0x01
#define EFI_TIME_IN_DAYLIGHT 0x02
//
// Value definition for EFI_TIME.TimeZone
//
#define EFI_UNSPECIFIED_TIMEZONE 0x07FF
//
// Networking
//
typedef struct {
UINT8 Addr[4];
} EFI_IPv4_ADDRESS;
typedef struct {
UINT8 Addr[16];
} EFI_IPv6_ADDRESS;
typedef struct {
UINT8 Addr[32];
} EFI_MAC_ADDRESS;
typedef union {
UINT32 Addr[4];
EFI_IPv4_ADDRESS v4;
EFI_IPv6_ADDRESS v6;
} EFI_IP_ADDRESS;
typedef enum {
EfiReservedMemoryType,
EfiLoaderCode,
EfiLoaderData,
EfiBootServicesCode,
EfiBootServicesData,
EfiRuntimeServicesCode,
EfiRuntimeServicesData,
EfiConventionalMemory,
EfiUnusableMemory,
EfiACPIReclaimMemory,
EfiACPIMemoryNVS,
EfiMemoryMappedIO,
EfiMemoryMappedIOPortSpace,
EfiPalCode,
EfiMaxMemoryType
} EFI_MEMORY_TYPE;
typedef enum {
AllocateAnyPages,
AllocateMaxAddress,
AllocateAddress,
MaxAllocateType
} EFI_ALLOCATE_TYPE;
typedef struct {
UINT64 Signature;
UINT32 Revision;
UINT32 HeaderSize;
UINT32 CRC32;
UINT32 Reserved;
} EFI_TABLE_HEADER;
//
// possible caching types for the memory range
//
#define EFI_MEMORY_UC 0x0000000000000001
#define EFI_MEMORY_WC 0x0000000000000002
#define EFI_MEMORY_WT 0x0000000000000004
#define EFI_MEMORY_WB 0x0000000000000008
#define EFI_MEMORY_UCE 0x0000000000000010
//
// physical memory protection on range
//
#define EFI_MEMORY_WP 0x0000000000001000
#define EFI_MEMORY_RP 0x0000000000002000
#define EFI_MEMORY_XP 0x0000000000004000
//
// range requires a runtime mapping
//
#define EFI_MEMORY_RUNTIME 0x8000000000000000ULL
typedef UINT64 EFI_PHYSICAL_ADDRESS;
typedef UINT64 EFI_VIRTUAL_ADDRESS;
#define EFI_MEMORY_DESCRIPTOR_VERSION 1
typedef struct {
UINT32 Type;
UINT32 Pad;
EFI_PHYSICAL_ADDRESS PhysicalStart;
EFI_VIRTUAL_ADDRESS VirtualStart;
UINT64 NumberOfPages;
UINT64 Attribute;
} EFI_MEMORY_DESCRIPTOR;
//
// The EFI memory allocation functions work in units of EFI_PAGEs that are
// 4K. This should in no way be confused with the page size of the processor.
// An EFI_PAGE is just the quanta of memory in EFI.
//
#define EFI_PAGE_SIZE 4096
#define EFI_PAGE_MASK 0xFFF
#define EFI_PAGE_SHIFT 12
#define EFI_SIZE_TO_PAGES(a) (((a) >> EFI_PAGE_SHIFT) + (((a) & EFI_PAGE_MASK) ? 1 : 0))
#define EFI_PAGES_TO_SIZE(a) ( (a) << EFI_PAGE_SHIFT)
//
// ALIGN_POINTER - aligns a pointer to the lowest boundry
//
#define ALIGN_POINTER(p, s) ((VOID *) (p + ((s - ((UINTN) p)) & (s - 1))))
//
// ALIGN_VARIABLE - aligns a variable up to the next natural boundry for int size of a processor
//
#define ALIGN_VARIABLE(Value, Adjustment) \
(UINTN) Adjustment = 0; \
if ((UINTN) Value % sizeof (UINTN)) { \
(UINTN) Adjustment = sizeof (UINTN) - ((UINTN) Value % sizeof (UINTN)); \
} \
Value = (UINTN) Value + (UINTN) Adjustment
//
// EFI_FIELD_OFFSET - returns the byte offset to a field within a structure
//
#define EFI_FIELD_OFFSET(TYPE,Field) ((UINTN)(&(((TYPE *) 0)->Field)))
//
// CONTAINING_RECORD - returns a pointer to the structure
// from one of it's elements.
//
#define _CR(Record, TYPE, Field) ((TYPE *) ((CHAR8 *) (Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))
//
// Define macros to build data structure signatures from characters.
//
#define EFI_SIGNATURE_16(A, B) ((A) | (B << 8))
#define EFI_SIGNATURE_32(A, B, C, D) (EFI_SIGNATURE_16 (A, B) | (EFI_SIGNATURE_16 (C, D) << 16))
#define EFI_SIGNATURE_64(A, B, C, D, E, F, G, H) \
(EFI_SIGNATURE_32 (A, B, C, D) | ((UINT64) (EFI_SIGNATURE_32 (E, F, G, H)) << 32))
#endif
| gpl-2.0 |
Gurgel100/gcc | gcc/testsuite/go.test/test/fixedbugs/issue20227.go | 565 | // errorcheck
// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Issue 20227: panic while constructing constant "1i/1e-600000000"
package p
var _ = 1 / 1e-600000000i // ERROR "division by zero"
var _ = 1i / 1e-600000000 // ERROR "division by zero"
var _ = 1i / 1e-600000000i // ERROR "division by zero"
var _ = 1 / (1e-600000000 + 1e-600000000i) // ERROR "division by zero"
var _ = 1i / (1e-600000000 + 1e-600000000i) // ERROR "division by zero"
| gpl-2.0 |
SanDisk-Open-Source/SSD_Dashboard | uefi/userspace/e2fsprogs-1.42.5/debugfs/logdump.c | 17342 | /*
* logdump.c --- dump the contents of the journal out to a file
*
* Authro: Stephen C. Tweedie, 2001 <[email protected]>
* Copyright (C) 2001 Red Hat, Inc.
* Based on portions Copyright (C) 1994 Theodore Ts'o.
*
* This file may be redistributed under the terms of the GNU Public
* License.
*/
#include "config.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <utime.h>
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern int optind;
extern char *optarg;
#endif
#include "debugfs.h"
#include "blkid/blkid.h"
#include "jfs_user.h"
#include <uuid/uuid.h>
enum journal_location {JOURNAL_IS_INTERNAL, JOURNAL_IS_EXTERNAL};
#define ANY_BLOCK ((blk_t) -1)
int dump_all, dump_contents, dump_descriptors;
blk_t block_to_dump, bitmap_to_dump, inode_block_to_dump;
unsigned int group_to_dump, inode_offset_to_dump;
ext2_ino_t inode_to_dump;
struct journal_source
{
enum journal_location where;
int fd;
ext2_file_t file;
};
static void dump_journal(char *, FILE *, struct journal_source *);
static void dump_descriptor_block(FILE *, struct journal_source *,
char *, journal_superblock_t *,
unsigned int *, int, tid_t);
static void dump_revoke_block(FILE *, char *, journal_superblock_t *,
unsigned int, int, tid_t);
static void dump_metadata_block(FILE *, struct journal_source *,
journal_superblock_t*,
unsigned int, unsigned int, unsigned int,
int, tid_t);
static void do_hexdump (FILE *, char *, int);
#define WRAP(jsb, blocknr) \
if (blocknr >= be32_to_cpu((jsb)->s_maxlen)) \
blocknr -= (be32_to_cpu((jsb)->s_maxlen) - \
be32_to_cpu((jsb)->s_first));
void do_logdump(int argc, char **argv)
{
int c;
int retval;
char *out_fn;
FILE *out_file;
char *inode_spec = NULL;
char *journal_fn = NULL;
int journal_fd = 0;
int use_sb = 0;
ext2_ino_t journal_inum;
struct ext2_inode journal_inode;
ext2_file_t journal_file;
char *tmp;
struct journal_source journal_source;
struct ext2_super_block *es = NULL;
journal_source.where = JOURNAL_IS_INTERNAL;
journal_source.fd = 0;
journal_source.file = 0;
dump_all = 0;
dump_contents = 0;
dump_descriptors = 1;
block_to_dump = ANY_BLOCK;
bitmap_to_dump = -1;
inode_block_to_dump = ANY_BLOCK;
inode_to_dump = -1;
reset_getopt();
while ((c = getopt (argc, argv, "ab:ci:f:s")) != EOF) {
switch (c) {
case 'a':
dump_all++;
break;
case 'b':
block_to_dump = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(argv[0], 0,
"Bad block number - %s", optarg);
return;
}
dump_descriptors = 0;
break;
case 'c':
dump_contents++;
break;
case 'f':
journal_fn = optarg;
break;
case 'i':
inode_spec = optarg;
dump_descriptors = 0;
break;
case 's':
use_sb++;
break;
default:
goto print_usage;
}
}
if (optind != argc && optind != argc-1) {
goto print_usage;
}
if (current_fs)
es = current_fs->super;
if (inode_spec) {
int inode_group, group_offset, inodes_per_block;
if (check_fs_open(argv[0]))
return;
inode_to_dump = string_to_inode(inode_spec);
if (!inode_to_dump)
return;
inode_group = ((inode_to_dump - 1)
/ es->s_inodes_per_group);
group_offset = ((inode_to_dump - 1)
% es->s_inodes_per_group);
inodes_per_block = (current_fs->blocksize
/ sizeof(struct ext2_inode));
inode_block_to_dump =
ext2fs_inode_table_loc(current_fs, inode_group) +
(group_offset / inodes_per_block);
inode_offset_to_dump = ((group_offset % inodes_per_block)
* sizeof(struct ext2_inode));
printf("Inode %u is at group %u, block %u, offset %u\n",
inode_to_dump, inode_group,
inode_block_to_dump, inode_offset_to_dump);
}
if (optind == argc) {
out_file = stdout;
} else {
out_fn = argv[optind];
out_file = fopen(out_fn, "w");
if (!out_file) {
com_err(argv[0], errno, "while opening %s for logdump",
out_fn);
goto errout;
}
}
if (block_to_dump != ANY_BLOCK && current_fs != NULL) {
group_to_dump = ((block_to_dump -
es->s_first_data_block)
/ es->s_blocks_per_group);
bitmap_to_dump = ext2fs_block_bitmap_loc(current_fs, group_to_dump);
}
if (!journal_fn && check_fs_open(argv[0]))
goto errout;
if (journal_fn) {
/* Set up to read journal from a regular file somewhere */
journal_fd = open(journal_fn, O_RDONLY, 0);
if (journal_fd < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
journal_fn);
goto errout;
}
journal_source.where = JOURNAL_IS_EXTERNAL;
journal_source.fd = journal_fd;
} else if ((journal_inum = es->s_journal_inum)) {
if (use_sb) {
if (es->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS) {
com_err(argv[0], 0,
"no journal backup in super block\n");
goto errout;
}
memset(&journal_inode, 0, sizeof(struct ext2_inode));
memcpy(&journal_inode.i_block[0], es->s_jnl_blocks,
EXT2_N_BLOCKS*4);
journal_inode.i_size_high = es->s_jnl_blocks[15];
journal_inode.i_size = es->s_jnl_blocks[16];
journal_inode.i_links_count = 1;
journal_inode.i_mode = LINUX_S_IFREG | 0600;
} else {
if (debugfs_read_inode(journal_inum, &journal_inode,
argv[0]))
goto errout;
}
retval = ext2fs_file_open2(current_fs, journal_inum,
&journal_inode, 0, &journal_file);
if (retval) {
com_err(argv[0], retval, "while opening ext2 file");
goto errout;
}
journal_source.where = JOURNAL_IS_INTERNAL;
journal_source.file = journal_file;
} else {
char uuid[37];
uuid_unparse(es->s_journal_uuid, uuid);
journal_fn = blkid_get_devname(NULL, "UUID", uuid);
if (!journal_fn)
journal_fn = blkid_devno_to_devname(es->s_journal_dev);
if (!journal_fn) {
com_err(argv[0], 0, "filesystem has no journal");
goto errout;
}
journal_fd = open(journal_fn, O_RDONLY, 0);
if (journal_fd < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
journal_fn);
free(journal_fn);
goto errout;
}
fprintf(out_file, "Using external journal found at %s\n",
journal_fn);
free(journal_fn);
journal_source.where = JOURNAL_IS_EXTERNAL;
journal_source.fd = journal_fd;
}
dump_journal(argv[0], out_file, &journal_source);
if (journal_source.where == JOURNAL_IS_INTERNAL)
ext2fs_file_close(journal_file);
else
close(journal_fd);
errout:
if (out_file && (out_file != stdout))
fclose(out_file);
return;
print_usage:
fprintf(stderr, "%s: Usage: logdump [-acs] [-b<block>] [-i<filespec>]\n\t"
"[-f<journal_file>] [output_file]\n", argv[0]);
}
static int read_journal_block(const char *cmd, struct journal_source *source,
off_t offset, char *buf, int size,
unsigned int *got)
{
int retval;
if (source->where == JOURNAL_IS_EXTERNAL) {
if (lseek(source->fd, offset, SEEK_SET) < 0) {
retval = errno;
com_err(cmd, retval, "while seeking in reading journal");
return retval;
}
retval = read(source->fd, buf, size);
if (retval >= 0) {
*got = retval;
retval = 0;
} else
retval = errno;
} else {
retval = ext2fs_file_lseek(source->file, offset,
EXT2_SEEK_SET, NULL);
if (retval) {
com_err(cmd, retval, "while seeking in reading journal");
return retval;
}
retval = ext2fs_file_read(source->file, buf, size, got);
}
if (retval)
com_err(cmd, retval, "while reading journal");
else if (*got != (unsigned int) size) {
com_err(cmd, 0, "short read (read %d, expected %d) "
"while reading journal", *got, size);
retval = -1;
}
return retval;
}
static const char *type_to_name(int btype)
{
switch (btype) {
case JFS_DESCRIPTOR_BLOCK:
return "descriptor block";
case JFS_COMMIT_BLOCK:
return "commit block";
case JFS_SUPERBLOCK_V1:
return "V1 superblock";
case JFS_SUPERBLOCK_V2:
return "V2 superblock";
case JFS_REVOKE_BLOCK:
return "revoke table";
}
return "unrecognised type";
}
static void dump_journal(char *cmdname, FILE *out_file,
struct journal_source *source)
{
struct ext2_super_block *sb;
char jsb_buffer[1024];
char buf[8192];
journal_superblock_t *jsb;
unsigned int blocksize = 1024;
unsigned int got;
int retval;
__u32 magic, sequence, blocktype;
journal_header_t *header;
tid_t transaction;
unsigned int blocknr = 0;
/* First, check to see if there's an ext2 superblock header */
retval = read_journal_block(cmdname, source, 0,
buf, 2048, &got);
if (retval)
return;
jsb = (journal_superblock_t *) buf;
sb = (struct ext2_super_block *) (buf+1024);
#ifdef WORDS_BIGENDIAN
if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(sb);
#endif
if ((be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) &&
(sb->s_magic == EXT2_SUPER_MAGIC) &&
(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
blocksize = EXT2_BLOCK_SIZE(sb);
blocknr = (blocksize == 1024) ? 2 : 1;
uuid_unparse(sb->s_uuid, jsb_buffer);
fprintf(out_file, "Ext2 superblock header found.\n");
if (dump_all) {
fprintf(out_file, "\tuuid=%s\n", jsb_buffer);
fprintf(out_file, "\tblocksize=%d\n", blocksize);
fprintf(out_file, "\tjournal data size %lu\n",
(unsigned long) ext2fs_blocks_count(sb));
}
}
/* Next, read the journal superblock */
retval = read_journal_block(cmdname, source, blocknr*blocksize,
jsb_buffer, 1024, &got);
if (retval)
return;
jsb = (journal_superblock_t *) jsb_buffer;
if (be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) {
fprintf(out_file,
"Journal superblock magic number invalid!\n");
return;
}
blocksize = be32_to_cpu(jsb->s_blocksize);
transaction = be32_to_cpu(jsb->s_sequence);
blocknr = be32_to_cpu(jsb->s_start);
fprintf(out_file, "Journal starts at block %u, transaction %u\n",
blocknr, transaction);
if (!blocknr)
/* Empty journal, nothing to do. */
return;
while (1) {
retval = read_journal_block(cmdname, source,
blocknr*blocksize, buf,
blocksize, &got);
if (retval || got != blocksize)
return;
header = (journal_header_t *) buf;
magic = be32_to_cpu(header->h_magic);
sequence = be32_to_cpu(header->h_sequence);
blocktype = be32_to_cpu(header->h_blocktype);
if (magic != JFS_MAGIC_NUMBER) {
fprintf (out_file, "No magic number at block %u: "
"end of journal.\n", blocknr);
return;
}
if (sequence != transaction) {
fprintf (out_file, "Found sequence %u (not %u) at "
"block %u: end of journal.\n",
sequence, transaction, blocknr);
return;
}
if (dump_descriptors) {
fprintf (out_file, "Found expected sequence %u, "
"type %u (%s) at block %u\n",
sequence, blocktype,
type_to_name(blocktype), blocknr);
}
switch (blocktype) {
case JFS_DESCRIPTOR_BLOCK:
dump_descriptor_block(out_file, source, buf, jsb,
&blocknr, blocksize,
transaction);
continue;
case JFS_COMMIT_BLOCK:
transaction++;
blocknr++;
WRAP(jsb, blocknr);
continue;
case JFS_REVOKE_BLOCK:
dump_revoke_block(out_file, buf, jsb,
blocknr, blocksize,
transaction);
blocknr++;
WRAP(jsb, blocknr);
continue;
default:
fprintf (out_file, "Unexpected block type %u at "
"block %u.\n", blocktype, blocknr);
return;
}
}
}
static void dump_descriptor_block(FILE *out_file,
struct journal_source *source,
char *buf,
journal_superblock_t *jsb,
unsigned int *blockp, int blocksize,
tid_t transaction)
{
int offset, tag_size = JBD_TAG_SIZE32;
char *tagp;
journal_block_tag_t *tag;
unsigned int blocknr;
__u32 tag_block;
__u32 tag_flags;
if (be32_to_cpu(jsb->s_feature_incompat) & JFS_FEATURE_INCOMPAT_64BIT)
tag_size = JBD_TAG_SIZE64;
offset = sizeof(journal_header_t);
blocknr = *blockp;
if (dump_all)
fprintf(out_file, "Dumping descriptor block, sequence %u, at "
"block %u:\n", transaction, blocknr);
++blocknr;
WRAP(jsb, blocknr);
do {
/* Work out the location of the current tag, and skip to
* the next one... */
tagp = &buf[offset];
tag = (journal_block_tag_t *) tagp;
offset += tag_size;
/* ... and if we have gone too far, then we've reached the
end of this block. */
if (offset > blocksize)
break;
tag_block = be32_to_cpu(tag->t_blocknr);
tag_flags = be32_to_cpu(tag->t_flags);
if (!(tag_flags & JFS_FLAG_SAME_UUID))
offset += 16;
dump_metadata_block(out_file, source, jsb,
blocknr, tag_block, tag_flags, blocksize,
transaction);
++blocknr;
WRAP(jsb, blocknr);
} while (!(tag_flags & JFS_FLAG_LAST_TAG));
*blockp = blocknr;
}
static void dump_revoke_block(FILE *out_file, char *buf,
journal_superblock_t *jsb EXT2FS_ATTR((unused)),
unsigned int blocknr,
int blocksize EXT2FS_ATTR((unused)),
tid_t transaction)
{
int offset, max;
journal_revoke_header_t *header;
unsigned int *entry, rblock;
if (dump_all)
fprintf(out_file, "Dumping revoke block, sequence %u, at "
"block %u:\n", transaction, blocknr);
header = (journal_revoke_header_t *) buf;
offset = sizeof(journal_revoke_header_t);
max = be32_to_cpu(header->r_count);
while (offset < max) {
entry = (unsigned int *) (buf + offset);
rblock = be32_to_cpu(*entry);
if (dump_all || rblock == block_to_dump) {
fprintf(out_file, " Revoke FS block %u", rblock);
if (dump_all)
fprintf(out_file, "\n");
else
fprintf(out_file," at block %u, sequence %u\n",
blocknr, transaction);
}
offset += 4;
}
}
static void show_extent(FILE *out_file, int start_extent, int end_extent,
__u32 first_block)
{
if (start_extent >= 0 && first_block != 0)
fprintf(out_file, "(%d+%u): %u ",
start_extent, end_extent-start_extent, first_block);
}
static void show_indirect(FILE *out_file, const char *name, __u32 where)
{
if (where)
fprintf(out_file, "(%s): %u ", name, where);
}
static void dump_metadata_block(FILE *out_file, struct journal_source *source,
journal_superblock_t *jsb EXT2FS_ATTR((unused)),
unsigned int log_blocknr,
unsigned int fs_blocknr,
unsigned int log_tag_flags,
int blocksize,
tid_t transaction)
{
unsigned int got;
int retval;
char buf[8192];
if (!(dump_all
|| (fs_blocknr == block_to_dump)
|| (fs_blocknr == inode_block_to_dump)
|| (fs_blocknr == bitmap_to_dump)))
return;
fprintf(out_file, " FS block %u logged at ", fs_blocknr);
if (!dump_all)
fprintf(out_file, "sequence %u, ", transaction);
fprintf(out_file, "journal block %u (flags 0x%x)\n", log_blocknr,
log_tag_flags);
/* There are two major special cases to parse:
*
* If this block is a block
* bitmap block, we need to give it special treatment so that we
* can log any allocates and deallocates which affect the
* block_to_dump query block.
*
* If the block is an inode block for the inode being searched
* for, then we need to dump the contents of that inode
* structure symbolically.
*/
if (!(dump_contents && dump_all)
&& fs_blocknr != block_to_dump
&& fs_blocknr != bitmap_to_dump
&& fs_blocknr != inode_block_to_dump)
return;
retval = read_journal_block("logdump", source,
blocksize * log_blocknr,
buf, blocksize, &got);
if (retval)
return;
if (fs_blocknr == bitmap_to_dump) {
struct ext2_super_block *super;
int offset;
super = current_fs->super;
offset = ((block_to_dump - super->s_first_data_block) %
super->s_blocks_per_group);
fprintf(out_file, " (block bitmap for block %u: "
"block is %s)\n",
block_to_dump,
ext2fs_test_bit(offset, buf) ? "SET" : "CLEAR");
}
if (fs_blocknr == inode_block_to_dump) {
struct ext2_inode *inode;
int first, prev, this, start_extent, i;
fprintf(out_file, " (inode block for inode %u):\n",
inode_to_dump);
inode = (struct ext2_inode *) (buf + inode_offset_to_dump);
internal_dump_inode(out_file, " ", inode_to_dump, inode, 0);
/* Dump out the direct/indirect blocks here:
* internal_dump_inode can only dump them from the main
* on-disk inode, not from the journaled copy of the
* inode. */
fprintf (out_file, " Blocks: ");
first = prev = start_extent = -1;
for (i=0; i<EXT2_NDIR_BLOCKS; i++) {
this = inode->i_block[i];
if (start_extent >= 0 && this == prev+1) {
prev = this;
continue;
} else {
show_extent(out_file, start_extent, i, first);
start_extent = i;
first = prev = this;
}
}
show_extent(out_file, start_extent, i, first);
show_indirect(out_file, "IND", inode->i_block[i++]);
show_indirect(out_file, "DIND", inode->i_block[i++]);
show_indirect(out_file, "TIND", inode->i_block[i++]);
fprintf(out_file, "\n");
}
if (dump_contents)
do_hexdump(out_file, buf, blocksize);
}
static void do_hexdump (FILE *out_file, char *buf, int blocksize)
{
int i,j;
int *intp;
char *charp;
unsigned char c;
intp = (int *) buf;
charp = (char *) buf;
for (i=0; i<blocksize; i+=16) {
fprintf(out_file, " %04x: ", i);
for (j=0; j<16; j+=4)
fprintf(out_file, "%08x ", *intp++);
for (j=0; j<16; j++) {
c = *charp++;
if (c < ' ' || c >= 127)
c = '.';
fprintf(out_file, "%c", c);
}
fprintf(out_file, "\n");
}
}
| gpl-2.0 |
TransmissionStudios/Transmission | sites/default/modules/panels/templates/panels-dashboard-link.tpl.php | 338 | <?php
// $Id: panels-dashboard-link.tpl.php,v 1.3 2010/10/11 22:56:02 sdboyer Exp $
?>
<div class="dashboard-entry clearfix">
<div class="dashboard-text">
<div class="dashboard-link">
<?php print $link['title']; ?>
</div>
<div class="description">
<?php print $link['description']; ?>
</div>
</div>
</div>
| gpl-2.0 |
piyushroshan/xen-4.3.2 | tools/qemu-xen/block/nbd.c | 16673 | /*
* QEMU Block driver for NBD
*
* Copyright (C) 2008 Bull S.A.S.
* Author: Laurent Vivier <[email protected]>
*
* Some parts:
* Copyright (C) 2007 Anthony Liguori <[email protected]>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "qemu-common.h"
#include "nbd.h"
#include "uri.h"
#include "block_int.h"
#include "module.h"
#include "qemu_socket.h"
#include <sys/types.h>
#include <unistd.h>
#define EN_OPTSTR ":exportname="
/* #define DEBUG_NBD */
#if defined(DEBUG_NBD)
#define logout(fmt, ...) \
fprintf(stderr, "nbd\t%-24s" fmt, __func__, ##__VA_ARGS__)
#else
#define logout(fmt, ...) ((void)0)
#endif
#define MAX_NBD_REQUESTS 16
#define HANDLE_TO_INDEX(bs, handle) ((handle) ^ ((uint64_t)(intptr_t)bs))
#define INDEX_TO_HANDLE(bs, index) ((index) ^ ((uint64_t)(intptr_t)bs))
typedef struct BDRVNBDState {
int sock;
uint32_t nbdflags;
off_t size;
size_t blocksize;
CoMutex send_mutex;
CoMutex free_sema;
Coroutine *send_coroutine;
int in_flight;
Coroutine *recv_coroutine[MAX_NBD_REQUESTS];
struct nbd_reply reply;
int is_unix;
char *host_spec;
char *export_name; /* An NBD server may export several devices */
} BDRVNBDState;
static int nbd_parse_uri(BDRVNBDState *s, const char *filename)
{
URI *uri;
const char *p;
QueryParams *qp = NULL;
int ret = 0;
uri = uri_parse(filename);
if (!uri) {
return -EINVAL;
}
/* transport */
if (!strcmp(uri->scheme, "nbd")) {
s->is_unix = false;
} else if (!strcmp(uri->scheme, "nbd+tcp")) {
s->is_unix = false;
} else if (!strcmp(uri->scheme, "nbd+unix")) {
s->is_unix = true;
} else {
ret = -EINVAL;
goto out;
}
p = uri->path ? uri->path : "/";
p += strspn(p, "/");
if (p[0]) {
s->export_name = g_strdup(p);
}
qp = query_params_parse(uri->query);
if (qp->n > 1 || (s->is_unix && !qp->n) || (!s->is_unix && qp->n)) {
ret = -EINVAL;
goto out;
}
if (s->is_unix) {
/* nbd+unix:///export?socket=path */
if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
ret = -EINVAL;
goto out;
}
s->host_spec = g_strdup(qp->p[0].value);
} else {
/* nbd[+tcp]://host:port/export */
if (!uri->server) {
ret = -EINVAL;
goto out;
}
if (!uri->port) {
uri->port = NBD_DEFAULT_PORT;
}
s->host_spec = g_strdup_printf("%s:%d", uri->server, uri->port);
}
out:
if (qp) {
query_params_free(qp);
}
uri_free(uri);
return ret;
}
static int nbd_config(BDRVNBDState *s, const char *filename)
{
char *file;
char *export_name;
const char *host_spec;
const char *unixpath;
int err = -EINVAL;
if (strstr(filename, "://")) {
return nbd_parse_uri(s, filename);
}
file = g_strdup(filename);
export_name = strstr(file, EN_OPTSTR);
if (export_name) {
if (export_name[strlen(EN_OPTSTR)] == 0) {
goto out;
}
export_name[0] = 0; /* truncate 'file' */
export_name += strlen(EN_OPTSTR);
s->export_name = g_strdup(export_name);
}
/* extract the host_spec - fail if it's not nbd:... */
if (!strstart(file, "nbd:", &host_spec)) {
goto out;
}
/* are we a UNIX or TCP socket? */
if (strstart(host_spec, "unix:", &unixpath)) {
s->is_unix = true;
s->host_spec = g_strdup(unixpath);
} else {
s->is_unix = false;
s->host_spec = g_strdup(host_spec);
}
err = 0;
out:
g_free(file);
if (err != 0) {
g_free(s->export_name);
g_free(s->host_spec);
}
return err;
}
static void nbd_coroutine_start(BDRVNBDState *s, struct nbd_request *request)
{
int i;
/* Poor man semaphore. The free_sema is locked when no other request
* can be accepted, and unlocked after receiving one reply. */
if (s->in_flight >= MAX_NBD_REQUESTS - 1) {
qemu_co_mutex_lock(&s->free_sema);
assert(s->in_flight < MAX_NBD_REQUESTS);
}
s->in_flight++;
for (i = 0; i < MAX_NBD_REQUESTS; i++) {
if (s->recv_coroutine[i] == NULL) {
s->recv_coroutine[i] = qemu_coroutine_self();
break;
}
}
assert(i < MAX_NBD_REQUESTS);
request->handle = INDEX_TO_HANDLE(s, i);
}
static int nbd_have_request(void *opaque)
{
BDRVNBDState *s = opaque;
return s->in_flight > 0;
}
static void nbd_reply_ready(void *opaque)
{
BDRVNBDState *s = opaque;
uint64_t i;
int ret;
if (s->reply.handle == 0) {
/* No reply already in flight. Fetch a header. It is possible
* that another thread has done the same thing in parallel, so
* the socket is not readable anymore.
*/
ret = nbd_receive_reply(s->sock, &s->reply);
if (ret == -EAGAIN) {
return;
}
if (ret < 0) {
s->reply.handle = 0;
goto fail;
}
}
/* There's no need for a mutex on the receive side, because the
* handler acts as a synchronization point and ensures that only
* one coroutine is called until the reply finishes. */
i = HANDLE_TO_INDEX(s, s->reply.handle);
if (i >= MAX_NBD_REQUESTS) {
goto fail;
}
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
return;
}
fail:
for (i = 0; i < MAX_NBD_REQUESTS; i++) {
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
}
}
}
static void nbd_restart_write(void *opaque)
{
BDRVNBDState *s = opaque;
qemu_coroutine_enter(s->send_coroutine, NULL);
}
static int nbd_co_send_request(BDRVNBDState *s, struct nbd_request *request,
QEMUIOVector *qiov, int offset)
{
int rc, ret;
qemu_co_mutex_lock(&s->send_mutex);
s->send_coroutine = qemu_coroutine_self();
qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, nbd_restart_write,
nbd_have_request, s);
rc = nbd_send_request(s->sock, request);
if (rc >= 0 && qiov) {
ret = qemu_co_sendv(s->sock, qiov->iov, qiov->niov,
offset, request->len);
if (ret != request->len) {
return -EIO;
}
}
qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, NULL,
nbd_have_request, s);
s->send_coroutine = NULL;
qemu_co_mutex_unlock(&s->send_mutex);
return rc;
}
static void nbd_co_receive_reply(BDRVNBDState *s, struct nbd_request *request,
struct nbd_reply *reply,
QEMUIOVector *qiov, int offset)
{
int ret;
/* Wait until we're woken up by the read handler. TODO: perhaps
* peek at the next reply and avoid yielding if it's ours? */
qemu_coroutine_yield();
*reply = s->reply;
if (reply->handle != request->handle) {
reply->error = EIO;
} else {
if (qiov && reply->error == 0) {
ret = qemu_co_recvv(s->sock, qiov->iov, qiov->niov,
offset, request->len);
if (ret != request->len) {
reply->error = EIO;
}
}
/* Tell the read handler to read another header. */
s->reply.handle = 0;
}
}
static void nbd_coroutine_end(BDRVNBDState *s, struct nbd_request *request)
{
int i = HANDLE_TO_INDEX(s, request->handle);
s->recv_coroutine[i] = NULL;
if (s->in_flight-- == MAX_NBD_REQUESTS) {
qemu_co_mutex_unlock(&s->free_sema);
}
}
static int nbd_establish_connection(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
int sock;
int ret;
off_t size;
size_t blocksize;
if (s->is_unix) {
sock = unix_socket_outgoing(s->host_spec);
} else {
sock = tcp_socket_outgoing_spec(s->host_spec);
}
/* Failed to establish connection */
if (sock < 0) {
logout("Failed to establish connection to NBD server\n");
return -errno;
}
/* NBD handshake */
ret = nbd_receive_negotiate(sock, s->export_name, &s->nbdflags, &size,
&blocksize);
if (ret < 0) {
logout("Failed to negotiate with the NBD server\n");
closesocket(sock);
return ret;
}
/* Now that we're connected, set the socket to be non-blocking and
* kick the reply mechanism. */
socket_set_nonblock(sock);
qemu_aio_set_fd_handler(sock, nbd_reply_ready, NULL,
nbd_have_request, s);
s->sock = sock;
s->size = size;
s->blocksize = blocksize;
logout("Established connection with NBD server\n");
return 0;
}
static void nbd_teardown_connection(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
request.type = NBD_CMD_DISC;
request.from = 0;
request.len = 0;
nbd_send_request(s->sock, &request);
qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL, NULL);
closesocket(s->sock);
}
static int nbd_open(BlockDriverState *bs, const char* filename, int flags)
{
BDRVNBDState *s = bs->opaque;
int result;
qemu_co_mutex_init(&s->send_mutex);
qemu_co_mutex_init(&s->free_sema);
/* Pop the config into our state object. Exit if invalid. */
result = nbd_config(s, filename);
if (result != 0) {
return result;
}
/* establish TCP connection, return error if it fails
* TODO: Configurable retry-until-timeout behaviour.
*/
result = nbd_establish_connection(bs);
return result;
}
static int nbd_co_readv_1(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, QEMUIOVector *qiov,
int offset)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
struct nbd_reply reply;
ssize_t ret;
request.type = NBD_CMD_READ;
request.from = sector_num * 512;
request.len = nb_sectors * 512;
nbd_coroutine_start(s, &request);
ret = nbd_co_send_request(s, &request, NULL, 0);
if (ret < 0) {
reply.error = -ret;
} else {
nbd_co_receive_reply(s, &request, &reply, qiov, offset);
}
nbd_coroutine_end(s, &request);
return -reply.error;
}
static int nbd_co_writev_1(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, QEMUIOVector *qiov,
int offset)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
struct nbd_reply reply;
ssize_t ret;
request.type = NBD_CMD_WRITE;
if (!bdrv_enable_write_cache(bs) && (s->nbdflags & NBD_FLAG_SEND_FUA)) {
request.type |= NBD_CMD_FLAG_FUA;
}
request.from = sector_num * 512;
request.len = nb_sectors * 512;
nbd_coroutine_start(s, &request);
ret = nbd_co_send_request(s, &request, qiov, offset);
if (ret < 0) {
reply.error = -ret;
} else {
nbd_co_receive_reply(s, &request, &reply, NULL, 0);
}
nbd_coroutine_end(s, &request);
return -reply.error;
}
/* qemu-nbd has a limit of slightly less than 1M per request. Try to
* remain aligned to 4K. */
#define NBD_MAX_SECTORS 2040
static int nbd_co_readv(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, QEMUIOVector *qiov)
{
int offset = 0;
int ret;
while (nb_sectors > NBD_MAX_SECTORS) {
ret = nbd_co_readv_1(bs, sector_num, NBD_MAX_SECTORS, qiov, offset);
if (ret < 0) {
return ret;
}
offset += NBD_MAX_SECTORS * 512;
sector_num += NBD_MAX_SECTORS;
nb_sectors -= NBD_MAX_SECTORS;
}
return nbd_co_readv_1(bs, sector_num, nb_sectors, qiov, offset);
}
static int nbd_co_writev(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, QEMUIOVector *qiov)
{
int offset = 0;
int ret;
while (nb_sectors > NBD_MAX_SECTORS) {
ret = nbd_co_writev_1(bs, sector_num, NBD_MAX_SECTORS, qiov, offset);
if (ret < 0) {
return ret;
}
offset += NBD_MAX_SECTORS * 512;
sector_num += NBD_MAX_SECTORS;
nb_sectors -= NBD_MAX_SECTORS;
}
return nbd_co_writev_1(bs, sector_num, nb_sectors, qiov, offset);
}
static int nbd_co_flush(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
struct nbd_reply reply;
ssize_t ret;
if (!(s->nbdflags & NBD_FLAG_SEND_FLUSH)) {
return 0;
}
request.type = NBD_CMD_FLUSH;
if (s->nbdflags & NBD_FLAG_SEND_FUA) {
request.type |= NBD_CMD_FLAG_FUA;
}
request.from = 0;
request.len = 0;
nbd_coroutine_start(s, &request);
ret = nbd_co_send_request(s, &request, NULL, 0);
if (ret < 0) {
reply.error = -ret;
} else {
nbd_co_receive_reply(s, &request, &reply, NULL, 0);
}
nbd_coroutine_end(s, &request);
return -reply.error;
}
static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num,
int nb_sectors)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
struct nbd_reply reply;
ssize_t ret;
if (!(s->nbdflags & NBD_FLAG_SEND_TRIM)) {
return 0;
}
request.type = NBD_CMD_TRIM;
request.from = sector_num * 512;;
request.len = nb_sectors * 512;
nbd_coroutine_start(s, &request);
ret = nbd_co_send_request(s, &request, NULL, 0);
if (ret < 0) {
reply.error = -ret;
} else {
nbd_co_receive_reply(s, &request, &reply, NULL, 0);
}
nbd_coroutine_end(s, &request);
return -reply.error;
}
static void nbd_close(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
g_free(s->export_name);
g_free(s->host_spec);
nbd_teardown_connection(bs);
}
static int64_t nbd_getlength(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
return s->size;
}
static BlockDriver bdrv_nbd = {
.format_name = "nbd",
.protocol_name = "nbd",
.instance_size = sizeof(BDRVNBDState),
.bdrv_file_open = nbd_open,
.bdrv_co_readv = nbd_co_readv,
.bdrv_co_writev = nbd_co_writev,
.bdrv_close = nbd_close,
.bdrv_co_flush_to_os = nbd_co_flush,
.bdrv_co_discard = nbd_co_discard,
.bdrv_getlength = nbd_getlength,
};
static BlockDriver bdrv_nbd_tcp = {
.format_name = "nbd",
.protocol_name = "nbd+tcp",
.instance_size = sizeof(BDRVNBDState),
.bdrv_file_open = nbd_open,
.bdrv_co_readv = nbd_co_readv,
.bdrv_co_writev = nbd_co_writev,
.bdrv_close = nbd_close,
.bdrv_co_flush_to_os = nbd_co_flush,
.bdrv_co_discard = nbd_co_discard,
.bdrv_getlength = nbd_getlength,
};
static BlockDriver bdrv_nbd_unix = {
.format_name = "nbd",
.protocol_name = "nbd+unix",
.instance_size = sizeof(BDRVNBDState),
.bdrv_file_open = nbd_open,
.bdrv_co_readv = nbd_co_readv,
.bdrv_co_writev = nbd_co_writev,
.bdrv_close = nbd_close,
.bdrv_co_flush_to_os = nbd_co_flush,
.bdrv_co_discard = nbd_co_discard,
.bdrv_getlength = nbd_getlength,
};
static void bdrv_nbd_init(void)
{
bdrv_register(&bdrv_nbd);
bdrv_register(&bdrv_nbd_tcp);
bdrv_register(&bdrv_nbd_unix);
}
block_init(bdrv_nbd_init);
| gpl-2.0 |
ernestovi/ups | spip/plugins-dist/statistiques/prive/squelettes/inclure/stats-visites-data.html | 855 | [(#BOITE_OUVRIR{[(#CHEMIN_IMAGE{statistique-24.png}|balise_img{'',cadre-icone})]<h1><:statistiques:titre_evolution_visite:></h1>,'simple stats'})]
<BOUCLE_expose(ARTICLES){id_article}{statut==.*}>
#BOITE_OUVRIR{'','note'}
<a class='annule_filtre' href="[(#SELF|parametre_url{id_article,''})]" title="<:info_tout_afficher|attribut_html:>">[(#CHEMIN_IMAGE{fermer-16.png}|balise_img|inserer_attribut{alt,<:info_tout_afficher:>})]</a>
<:statistiques:titre_page_statistiques_visites:> <:info_pour:>
<h2 class='objet_titre'><a href='#URL_ARTICLE'>#TITRE</a></h2>
<a href="#URL_ECRIRE{stats_referers,id_article=#ID_ARTICLE}"><:statistiques:titre_liens_entrants:></a>
#BOITE_FERMER
</BOUCLE_expose>
<INCLURE{fond=prive/squelettes/inclure/stats-visites-jours,ajax,env} />
<INCLURE{fond=prive/squelettes/inclure/stats-visites-mois,ajax,env} />
#BOITE_FERMER
| gpl-3.0 |
debard/georchestra-ird | mapfishapp/src/main/webapp/lib/proj4js/lib/defs/EPSG2246.js | 210 | Proj4js.defs["EPSG:2246"] = "+proj=lcc +lat_1=37.96666666666667 +lat_2=38.96666666666667 +lat_0=37.5 +lon_0=-84.25 +x_0=500000.0001016001 +y_0=0 +ellps=GRS80 +datum=NAD83 +to_meter=0.3048006096012192 +no_defs"; | gpl-3.0 |
freaxmind/miage-l3 | web/blog Tim Burton/tim_burton/protected/extensions/tinymce/assets/tiny_mce/plugins/wordc/langs/ka_dlg.js | 50 | tinyMCE.addI18n('ka.wordcount',{words:"Words: "}); | gpl-3.0 |
SkyroverTech/SkyroverCF | lib/cppcheck-1.71/gui/xmlreportv1.cpp | 5973 | /*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2015 Daniel Marjamäki and Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <QObject>
#include <QString>
#include <QList>
#include <QDir>
#include <QXmlStreamWriter>
#include <QDebug>
#include "report.h"
#include "erroritem.h"
#include "xmlreport.h"
#include "xmlreportv1.h"
static const char ResultElementName[] = "results";
static const char ErrorElementName[] = "error";
static const char FilenameAttribute[] = "file";
static const char LineAttribute[] = "line";
static const char IdAttribute[] = "id";
static const char SeverityAttribute[] = "severity";
static const char MsgAttribute[] = "msg";
XmlReportV1::XmlReportV1(const QString &filename) :
XmlReport(filename),
mXmlReader(NULL),
mXmlWriter(NULL)
{
}
XmlReportV1::~XmlReportV1()
{
delete mXmlReader;
delete mXmlWriter;
}
bool XmlReportV1::Create()
{
if (Report::Create()) {
mXmlWriter = new QXmlStreamWriter(Report::GetFile());
return true;
}
return false;
}
bool XmlReportV1::Open()
{
if (Report::Open()) {
mXmlReader = new QXmlStreamReader(Report::GetFile());
return true;
}
return false;
}
void XmlReportV1::WriteHeader()
{
mXmlWriter->setAutoFormatting(true);
mXmlWriter->writeStartDocument();
mXmlWriter->writeStartElement(ResultElementName);
}
void XmlReportV1::WriteFooter()
{
mXmlWriter->writeEndElement();
mXmlWriter->writeEndDocument();
}
void XmlReportV1::WriteError(const ErrorItem &error)
{
/*
Error example from the core program in xml
<error file="gui/test.cpp" line="14" id="mismatchAllocDealloc" severity="error" msg="Mismatching allocation and deallocation: k"/>
The callstack seems to be ignored here as well, instead last item of the stack is used
*/
// Don't write inconclusive errors to XML V1
if (error.inconclusive)
return;
mXmlWriter->writeStartElement(ErrorElementName);
QString file = QDir::toNativeSeparators(error.files[error.files.size() - 1]);
file = XmlReport::quoteMessage(file);
mXmlWriter->writeAttribute(FilenameAttribute, file);
const QString line = QString::number(error.lines[error.lines.size() - 1]);
mXmlWriter->writeAttribute(LineAttribute, line);
mXmlWriter->writeAttribute(IdAttribute, error.errorId);
// Don't localize severity so we can read these files
mXmlWriter->writeAttribute(SeverityAttribute, GuiSeverity::toString(error.severity));
const QString message = XmlReport::quoteMessage(error.message);
mXmlWriter->writeAttribute(MsgAttribute, message);
mXmlWriter->writeEndElement();
}
QList<ErrorItem> XmlReportV1::Read()
{
QList<ErrorItem> errors;
bool insideResults = false;
if (!mXmlReader) {
qDebug() << "You must Open() the file before reading it!";
return errors;
}
while (!mXmlReader->atEnd()) {
switch (mXmlReader->readNext()) {
case QXmlStreamReader::StartElement:
if (mXmlReader->name() == ResultElementName)
insideResults = true;
// Read error element from inside result element
if (insideResults && mXmlReader->name() == ErrorElementName) {
ErrorItem item = ReadError(mXmlReader);
errors.append(item);
}
break;
case QXmlStreamReader::EndElement:
if (mXmlReader->name() == ResultElementName)
insideResults = false;
break;
// Not handled
case QXmlStreamReader::NoToken:
case QXmlStreamReader::Invalid:
case QXmlStreamReader::StartDocument:
case QXmlStreamReader::EndDocument:
case QXmlStreamReader::Characters:
case QXmlStreamReader::Comment:
case QXmlStreamReader::DTD:
case QXmlStreamReader::EntityReference:
case QXmlStreamReader::ProcessingInstruction:
break;
}
}
return errors;
}
ErrorItem XmlReportV1::ReadError(QXmlStreamReader *reader)
{
ErrorItem item;
if (reader->name().toString() == ErrorElementName) {
QXmlStreamAttributes attribs = reader->attributes();
QString file = attribs.value("", FilenameAttribute).toString();
file = XmlReport::unquoteMessage(file);
item.file = file;
item.files.push_back(file);
const int line = attribs.value("", LineAttribute).toString().toUInt();
item.lines.push_back(line);
item.errorId = attribs.value("", IdAttribute).toString();
item.severity = GuiSeverity::fromString(attribs.value("", SeverityAttribute).toString());
// NOTE: This duplicates the message to Summary-field. But since
// old XML format doesn't have separate summary and verbose messages
// we must add same message to both data so it shows up in GUI.
// Check if there is full stop and cut the summary to it.
QString summary = attribs.value("", MsgAttribute).toString();
const int ind = summary.indexOf('.');
if (ind != -1)
summary = summary.left(ind + 1);
item.summary = XmlReport::unquoteMessage(summary);
QString message = attribs.value("", MsgAttribute).toString();
item.message = XmlReport::unquoteMessage(message);
}
return item;
}
| gpl-3.0 |
betaflight/betaflight | lib/main/STM32G4/Drivers/STM32G4xx_HAL_Driver/Inc/stm32g4xx_hal_i2c_ex.h | 6081 | /**
******************************************************************************
* @file stm32g4xx_hal_i2c_ex.h
* @author MCD Application Team
* @brief Header file of I2C HAL Extended module.
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2017 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef STM32G4xx_HAL_I2C_EX_H
#define STM32G4xx_HAL_I2C_EX_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "stm32g4xx_hal_def.h"
/** @addtogroup STM32G4xx_HAL_Driver
* @{
*/
/** @addtogroup I2CEx
* @{
*/
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/** @defgroup I2CEx_Exported_Constants I2C Extended Exported Constants
* @{
*/
/** @defgroup I2CEx_Analog_Filter I2C Extended Analog Filter
* @{
*/
#define I2C_ANALOGFILTER_ENABLE 0x00000000U
#define I2C_ANALOGFILTER_DISABLE I2C_CR1_ANFOFF
/**
* @}
*/
/** @defgroup I2CEx_FastModePlus I2C Extended Fast Mode Plus
* @{
*/
#define I2C_FMP_NOT_SUPPORTED 0xAAAA0000U /*!< Fast Mode Plus not supported */
#define I2C_FASTMODEPLUS_PB6 SYSCFG_CFGR1_I2C_PB6_FMP /*!< Enable Fast Mode Plus on PB6 */
#define I2C_FASTMODEPLUS_PB7 SYSCFG_CFGR1_I2C_PB7_FMP /*!< Enable Fast Mode Plus on PB7 */
#define I2C_FASTMODEPLUS_PB8 SYSCFG_CFGR1_I2C_PB8_FMP /*!< Enable Fast Mode Plus on PB8 */
#define I2C_FASTMODEPLUS_PB9 SYSCFG_CFGR1_I2C_PB9_FMP /*!< Enable Fast Mode Plus on PB9 */
#define I2C_FASTMODEPLUS_I2C1 SYSCFG_CFGR1_I2C1_FMP /*!< Enable Fast Mode Plus on I2C1 pins */
#define I2C_FASTMODEPLUS_I2C2 SYSCFG_CFGR1_I2C2_FMP /*!< Enable Fast Mode Plus on I2C2 pins */
#define I2C_FASTMODEPLUS_I2C3 SYSCFG_CFGR1_I2C3_FMP /*!< Enable Fast Mode Plus on I2C3 pins */
#if defined(SYSCFG_CFGR1_I2C4_FMP)
#define I2C_FASTMODEPLUS_I2C4 SYSCFG_CFGR1_I2C4_FMP /*!< Enable Fast Mode Plus on I2C4 pins */
#else
#define I2C_FASTMODEPLUS_I2C4 (uint32_t)(0x00000800U | I2C_FMP_NOT_SUPPORTED) /*!< Fast Mode Plus I2C4 not supported */
#endif
/**
* @}
*/
/**
* @}
*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup I2CEx_Exported_Functions I2C Extended Exported Functions
* @{
*/
/** @addtogroup I2CEx_Exported_Functions_Group1 Extended features functions
* @brief Extended features functions
* @{
*/
/* Peripheral Control functions ************************************************/
HAL_StatusTypeDef HAL_I2CEx_ConfigAnalogFilter(I2C_HandleTypeDef *hi2c, uint32_t AnalogFilter);
HAL_StatusTypeDef HAL_I2CEx_ConfigDigitalFilter(I2C_HandleTypeDef *hi2c, uint32_t DigitalFilter);
HAL_StatusTypeDef HAL_I2CEx_EnableWakeUp(I2C_HandleTypeDef *hi2c);
HAL_StatusTypeDef HAL_I2CEx_DisableWakeUp(I2C_HandleTypeDef *hi2c);
void HAL_I2CEx_EnableFastModePlus(uint32_t ConfigFastModePlus);
void HAL_I2CEx_DisableFastModePlus(uint32_t ConfigFastModePlus);
/* Private constants ---------------------------------------------------------*/
/** @defgroup I2CEx_Private_Constants I2C Extended Private Constants
* @{
*/
/**
* @}
*/
/* Private macros ------------------------------------------------------------*/
/** @defgroup I2CEx_Private_Macro I2C Extended Private Macros
* @{
*/
#define IS_I2C_ANALOG_FILTER(FILTER) (((FILTER) == I2C_ANALOGFILTER_ENABLE) || \
((FILTER) == I2C_ANALOGFILTER_DISABLE))
#define IS_I2C_DIGITAL_FILTER(FILTER) ((FILTER) <= 0x0000000FU)
#define IS_I2C_FASTMODEPLUS(__CONFIG__) ((((__CONFIG__) & I2C_FMP_NOT_SUPPORTED) != I2C_FMP_NOT_SUPPORTED) && \
((((__CONFIG__) & (I2C_FASTMODEPLUS_PB6)) == I2C_FASTMODEPLUS_PB6) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_PB7)) == I2C_FASTMODEPLUS_PB7) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_PB8)) == I2C_FASTMODEPLUS_PB8) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_PB9)) == I2C_FASTMODEPLUS_PB9) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_I2C1)) == I2C_FASTMODEPLUS_I2C1) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_I2C2)) == I2C_FASTMODEPLUS_I2C2) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_I2C3)) == I2C_FASTMODEPLUS_I2C3) || \
(((__CONFIG__) & (I2C_FASTMODEPLUS_I2C4)) == I2C_FASTMODEPLUS_I2C4)))
/**
* @}
*/
/* Private Functions ---------------------------------------------------------*/
/** @defgroup I2CEx_Private_Functions I2C Extended Private Functions
* @{
*/
/* Private functions are defined in stm32g4xx_hal_i2c_ex.c file */
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* STM32G4xx_HAL_I2C_EX_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
| gpl-3.0 |
damnya/dnSpy | ILSpy/Services/ParserService.cs | 2300 | // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Collections.Generic;
namespace ICSharpCode.ILSpy.Debugger.Services
{
/// <summary>
/// Very naive parser.
/// </summary>
static class ParserService
{
static HashSet<string> mySet = new HashSet<string>();
static ParserService()
{
mySet.AddRange((new string [] {
".",
"{",
"}",
"(",
")",
"[",
"]",
" ",
"=",
"+",
"-",
"/",
"%",
"*",
"&",
Environment.NewLine,
";",
",",
"~",
"!",
"?",
@"\n",
@"\t",
@"\r",
"|"
}));
}
static void AddRange<T>(this ICollection<T> list, IEnumerable<T> items)
{
foreach (T item in items)
if (!list.Contains(item))
list.Add(item);
}
/// <summary>
/// Returns the variable name
/// </summary>
/// <param name="fullText"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static string SimpleParseAt(string fullText, int offset)
{
if (string.IsNullOrEmpty(fullText))
return string.Empty;
if (offset <= 0 || offset >= fullText.Length)
return string.Empty;
string currentValue = fullText[offset].ToString();
if (mySet.Contains(currentValue))
return string.Empty;
int left = offset, right = offset;
//search left
while((!mySet.Contains(currentValue) || currentValue == ".") && left > 0)
currentValue = fullText[--left].ToString();
currentValue = fullText[offset].ToString();
// searh right
while(!mySet.Contains(currentValue) && right < fullText.Length - 2)
currentValue = fullText[++right].ToString();
return fullText.Substring(left + 1, right - 1 - left).Trim();
}
}
}
| gpl-3.0 |
Scavenge/darkstar | scripts/zones/PsoXja/npcs/_091.lua | 2875 | -----------------------------------
-- Area: Pso'Xja
-- NPC: _091 (Stone Gate)
-- Notes: Spawns Gargoyle when triggered
-- @pos 350.000 -1.925 -61.600 9
-----------------------------------
package.loaded["scripts/zones/PsoXja/TextIDs"] = nil;
-----------------------------------
require("scripts/globals/status");
require("scripts/zones/PsoXja/TextIDs");
require("scripts/globals/keyitems");
-----------------------------------
-- onTrade
-----------------------------------
function onTrade(player,npc,trade)
if ((trade:hasItemQty(1115,1) or trade:hasItemQty(1023,1) or trade:hasItemQty(1022,1)) and trade:getItemCount() == 1 and player:getMainJob() == JOBS.THF) then
local Z=player:getZPos();
if (npc:getAnimation() == 9) then
if (Z >= -61) then
if (GetMobAction(16814082) == 0) then
local Rand = math.random(1,2); -- estimated 50% success as per the wiki
if (Rand == 1) then -- Spawn Gargoyle
player:messageSpecial(DISCOVER_DISARM_FAIL + 0x8000, 0, 0, 0, 0, true);
SpawnMob(16814082):updateClaim(player); -- Gargoyle
else
player:messageSpecial(DISCOVER_DISARM_SUCCESS + 0x8000, 0, 0, 0, 0, true);
npc:openDoor(30);
end
player:tradeComplete();
else
player:messageSpecial(DOOR_LOCKED);
end
end
end
end
end;
-----------------------------------
-- onTrigger
-----------------------------------
function onTrigger(player,npc)
local Z=player:getZPos();
if (npc:getAnimation() == 9) then
if (Z >= -61) then
if (GetMobAction(16814082) == 0) then
local Rand = math.random(1,10);
if (Rand <=9) then -- Spawn Gargoyle
player:messageSpecial(TRAP_ACTIVATED + 0x8000, 0, 0, 0, 0, true);
SpawnMob(16814082):updateClaim(player); -- Gargoyle
else
player:messageSpecial(TRAP_FAILS + 0x8000, 0, 0, 0, 0, true);
npc:openDoor(30);
end
else
player:messageSpecial(DOOR_LOCKED);
end
elseif (Z <= -62) then
player:startEvent(0x001A);
end
end
end;
-----------------------------------
-- onEventUpdate
-----------------------------------
function onEventUpdate(player,csid,option)
-- printf("CSID: %u",csid);
-- printf("RESULT: %u",option);
end;
-----------------------------------
-- onEventFinish
-----------------------------------
function onEventFinish(player,csid,option)
if (csid == 0x001A and option == 1) then
player:setPos(260,-0.25,-20,254,111);
end
end; | gpl-3.0 |
OshinKaramian/jsmc | server/ffmpeg/linux/libavcodec/ass_split.c | 23515 | /*
* SSA/ASS spliting functions
* Copyright (c) 2010 Aurelien Jacobs <[email protected]>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
#include "ass_split.h"
typedef enum {
ASS_STR,
ASS_INT,
ASS_FLT,
ASS_COLOR,
ASS_TIMESTAMP,
ASS_ALGN,
} ASSFieldType;
typedef struct {
const char *name;
int type;
int offset;
} ASSFields;
typedef struct {
const char *section;
const char *format_header;
const char *fields_header;
int size;
int offset;
int offset_count;
ASSFields fields[24];
} ASSSection;
static const ASSSection ass_sections[] = {
{ .section = "Script Info",
.offset = offsetof(ASS, script_info),
.fields = {{"ScriptType", ASS_STR, offsetof(ASSScriptInfo, script_type)},
{"Collisions", ASS_STR, offsetof(ASSScriptInfo, collisions) },
{"PlayResX", ASS_INT, offsetof(ASSScriptInfo, play_res_x) },
{"PlayResY", ASS_INT, offsetof(ASSScriptInfo, play_res_y) },
{"Timer", ASS_FLT, offsetof(ASSScriptInfo, timer) },
{0},
}
},
{ .section = "V4+ Styles",
.format_header = "Format",
.fields_header = "Style",
.size = sizeof(ASSStyle),
.offset = offsetof(ASS, styles),
.offset_count = offsetof(ASS, styles_count),
.fields = {{"Name", ASS_STR, offsetof(ASSStyle, name) },
{"Fontname", ASS_STR, offsetof(ASSStyle, font_name) },
{"Fontsize", ASS_INT, offsetof(ASSStyle, font_size) },
{"PrimaryColour", ASS_COLOR, offsetof(ASSStyle, primary_color) },
{"SecondaryColour", ASS_COLOR, offsetof(ASSStyle, secondary_color)},
{"OutlineColour", ASS_COLOR, offsetof(ASSStyle, outline_color) },
{"BackColour", ASS_COLOR, offsetof(ASSStyle, back_color) },
{"Bold", ASS_INT, offsetof(ASSStyle, bold) },
{"Italic", ASS_INT, offsetof(ASSStyle, italic) },
{"Underline", ASS_INT, offsetof(ASSStyle, underline) },
{"StrikeOut", ASS_INT, offsetof(ASSStyle, strikeout) },
{"ScaleX", ASS_FLT, offsetof(ASSStyle, scalex) },
{"ScaleY", ASS_FLT, offsetof(ASSStyle, scaley) },
{"Spacing", ASS_FLT, offsetof(ASSStyle, spacing) },
{"Angle", ASS_FLT, offsetof(ASSStyle, angle) },
{"BorderStyle", ASS_INT, offsetof(ASSStyle, border_style) },
{"Outline", ASS_FLT, offsetof(ASSStyle, outline) },
{"Shadow", ASS_FLT, offsetof(ASSStyle, shadow) },
{"Alignment", ASS_INT, offsetof(ASSStyle, alignment) },
{"MarginL", ASS_INT, offsetof(ASSStyle, margin_l) },
{"MarginR", ASS_INT, offsetof(ASSStyle, margin_r) },
{"MarginV", ASS_INT, offsetof(ASSStyle, margin_v) },
{"Encoding", ASS_INT, offsetof(ASSStyle, encoding) },
{0},
}
},
{ .section = "V4 Styles",
.format_header = "Format",
.fields_header = "Style",
.size = sizeof(ASSStyle),
.offset = offsetof(ASS, styles),
.offset_count = offsetof(ASS, styles_count),
.fields = {{"Name", ASS_STR, offsetof(ASSStyle, name) },
{"Fontname", ASS_STR, offsetof(ASSStyle, font_name) },
{"Fontsize", ASS_INT, offsetof(ASSStyle, font_size) },
{"PrimaryColour", ASS_COLOR, offsetof(ASSStyle, primary_color) },
{"SecondaryColour", ASS_COLOR, offsetof(ASSStyle, secondary_color)},
{"TertiaryColour", ASS_COLOR, offsetof(ASSStyle, outline_color) },
{"BackColour", ASS_COLOR, offsetof(ASSStyle, back_color) },
{"Bold", ASS_INT, offsetof(ASSStyle, bold) },
{"Italic", ASS_INT, offsetof(ASSStyle, italic) },
{"BorderStyle", ASS_INT, offsetof(ASSStyle, border_style) },
{"Outline", ASS_FLT, offsetof(ASSStyle, outline) },
{"Shadow", ASS_FLT, offsetof(ASSStyle, shadow) },
{"Alignment", ASS_ALGN, offsetof(ASSStyle, alignment) },
{"MarginL", ASS_INT, offsetof(ASSStyle, margin_l) },
{"MarginR", ASS_INT, offsetof(ASSStyle, margin_r) },
{"MarginV", ASS_INT, offsetof(ASSStyle, margin_v) },
{"AlphaLevel", ASS_INT, offsetof(ASSStyle, alpha_level) },
{"Encoding", ASS_INT, offsetof(ASSStyle, encoding) },
{0},
}
},
{ .section = "Events",
.format_header = "Format",
.fields_header = "Dialogue",
.size = sizeof(ASSDialog),
.offset = offsetof(ASS, dialogs),
.offset_count = offsetof(ASS, dialogs_count),
.fields = {{"Layer", ASS_INT, offsetof(ASSDialog, layer) },
{"Start", ASS_TIMESTAMP, offsetof(ASSDialog, start) },
{"End", ASS_TIMESTAMP, offsetof(ASSDialog, end) },
{"Style", ASS_STR, offsetof(ASSDialog, style) },
{"Name", ASS_STR, offsetof(ASSDialog, name) },
{"MarginL", ASS_INT, offsetof(ASSDialog, margin_l)},
{"MarginR", ASS_INT, offsetof(ASSDialog, margin_r)},
{"MarginV", ASS_INT, offsetof(ASSDialog, margin_v)},
{"Effect", ASS_STR, offsetof(ASSDialog, effect) },
{"Text", ASS_STR, offsetof(ASSDialog, text) },
{0},
}
},
};
typedef int (*ASSConvertFunc)(void *dest, const char *buf, int len);
static int convert_str(void *dest, const char *buf, int len)
{
char *str = av_malloc(len + 1);
if (str) {
memcpy(str, buf, len);
str[len] = 0;
if (*(void **)dest)
av_free(*(void **)dest);
*(char **)dest = str;
}
return !str;
}
static int convert_int(void *dest, const char *buf, int len)
{
return sscanf(buf, "%d", (int *)dest) == 1;
}
static int convert_flt(void *dest, const char *buf, int len)
{
return sscanf(buf, "%f", (float *)dest) == 1;
}
static int convert_color(void *dest, const char *buf, int len)
{
return sscanf(buf, "&H%8x", (int *)dest) == 1 ||
sscanf(buf, "%d", (int *)dest) == 1;
}
static int convert_timestamp(void *dest, const char *buf, int len)
{
int c, h, m, s, cs;
if ((c = sscanf(buf, "%d:%02d:%02d.%02d", &h, &m, &s, &cs)) == 4)
*(int *)dest = 360000*h + 6000*m + 100*s + cs;
return c == 4;
}
static int convert_alignment(void *dest, const char *buf, int len)
{
int a;
if (sscanf(buf, "%d", &a) == 1) {
/* convert V4 Style alignment to V4+ Style */
*(int *)dest = a + ((a&4) >> 1) - 5*!!(a&8);
return 1;
}
return 0;
}
static const ASSConvertFunc convert_func[] = {
[ASS_STR] = convert_str,
[ASS_INT] = convert_int,
[ASS_FLT] = convert_flt,
[ASS_COLOR] = convert_color,
[ASS_TIMESTAMP] = convert_timestamp,
[ASS_ALGN] = convert_alignment,
};
struct ASSSplitContext {
ASS ass;
int current_section;
int field_number[FF_ARRAY_ELEMS(ass_sections)];
int *field_order[FF_ARRAY_ELEMS(ass_sections)];
};
static uint8_t *realloc_section_array(ASSSplitContext *ctx)
{
const ASSSection *section = &ass_sections[ctx->current_section];
int *count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
void **section_ptr = (void **)((uint8_t *)&ctx->ass + section->offset);
uint8_t *tmp = av_realloc_array(*section_ptr, (*count+1), section->size);
if (!tmp)
return NULL;
*section_ptr = tmp;
tmp += *count * section->size;
memset(tmp, 0, section->size);
(*count)++;
return tmp;
}
static inline int is_eol(char buf)
{
return buf == '\r' || buf == '\n' || buf == 0;
}
static inline const char *skip_space(const char *buf)
{
while (*buf == ' ')
buf++;
return buf;
}
static int *get_default_field_orders(const ASSSection *section, int *number)
{
int i;
int *order = av_malloc_array(FF_ARRAY_ELEMS(section->fields), sizeof(*order));
if (!order)
return NULL;
for (i = 0; section->fields[i].name; i++)
order[i] = i;
*number = i;
while (i < FF_ARRAY_ELEMS(section->fields))
order[i++] = -1;
return order;
}
static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
{
const ASSSection *section = &ass_sections[ctx->current_section];
int *number = &ctx->field_number[ctx->current_section];
int *order = ctx->field_order[ctx->current_section];
int *tmp, i, len;
while (buf && *buf) {
if (buf[0] == '[') {
ctx->current_section = -1;
break;
}
if (buf[0] == ';' || (buf[0] == '!' && buf[1] == ':'))
goto next_line; // skip comments
len = strcspn(buf, ":\r\n");
if (buf[len] == ':' &&
(!section->fields_header || strncmp(buf, section->fields_header, len))) {
for (i = 0; i < FF_ARRAY_ELEMS(ass_sections); i++) {
if (ass_sections[i].fields_header &&
!strncmp(buf, ass_sections[i].fields_header, len)) {
ctx->current_section = i;
section = &ass_sections[ctx->current_section];
number = &ctx->field_number[ctx->current_section];
order = ctx->field_order[ctx->current_section];
break;
}
}
}
if (section->format_header && !order) {
len = strlen(section->format_header);
if (!strncmp(buf, section->format_header, len) && buf[len] == ':') {
buf += len + 1;
while (!is_eol(*buf)) {
buf = skip_space(buf);
len = strcspn(buf, ", \r\n");
if (!(tmp = av_realloc_array(order, (*number + 1), sizeof(*order))))
return NULL;
order = tmp;
order[*number] = -1;
for (i=0; section->fields[i].name; i++)
if (!strncmp(buf, section->fields[i].name, len)) {
order[*number] = i;
break;
}
(*number)++;
buf = skip_space(buf + len + (buf[len] == ','));
}
ctx->field_order[ctx->current_section] = order;
goto next_line;
}
}
if (section->fields_header) {
len = strlen(section->fields_header);
if (!strncmp(buf, section->fields_header, len) && buf[len] == ':') {
uint8_t *ptr, *struct_ptr = realloc_section_array(ctx);
if (!struct_ptr) return NULL;
/* No format header line found so far, assume default */
if (!order) {
order = get_default_field_orders(section, number);
if (!order)
return NULL;
ctx->field_order[ctx->current_section] = order;
}
buf += len + 1;
for (i=0; !is_eol(*buf) && i < *number; i++) {
int last = i == *number - 1;
buf = skip_space(buf);
len = strcspn(buf, last ? "\r\n" : ",\r\n");
if (order[i] >= 0) {
ASSFieldType type = section->fields[order[i]].type;
ptr = struct_ptr + section->fields[order[i]].offset;
convert_func[type](ptr, buf, len);
}
buf += len;
if (!last && *buf) buf++;
buf = skip_space(buf);
}
}
} else {
len = strcspn(buf, ":\r\n");
if (buf[len] == ':') {
for (i=0; section->fields[i].name; i++)
if (!strncmp(buf, section->fields[i].name, len)) {
ASSFieldType type = section->fields[i].type;
uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
ptr += section->fields[i].offset;
buf = skip_space(buf + len + 1);
convert_func[type](ptr, buf, strcspn(buf, "\r\n"));
break;
}
}
}
next_line:
buf += strcspn(buf, "\n");
buf += !!*buf;
}
return buf;
}
static int ass_split(ASSSplitContext *ctx, const char *buf)
{
char c, section[16];
int i;
if (ctx->current_section >= 0)
buf = ass_split_section(ctx, buf);
while (buf && *buf) {
if (sscanf(buf, "[%15[0-9A-Za-z+ ]]%c", section, &c) == 2) {
buf += strcspn(buf, "\n");
buf += !!*buf;
for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
if (!strcmp(section, ass_sections[i].section)) {
ctx->current_section = i;
buf = ass_split_section(ctx, buf);
}
} else {
buf += strcspn(buf, "\n");
buf += !!*buf;
}
}
return buf ? 0 : AVERROR_INVALIDDATA;
}
ASSSplitContext *ff_ass_split(const char *buf)
{
ASSSplitContext *ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return NULL;
ctx->current_section = -1;
if (ass_split(ctx, buf) < 0) {
ff_ass_split_free(ctx);
return NULL;
}
return ctx;
}
static void free_section(ASSSplitContext *ctx, const ASSSection *section)
{
uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
int i, j, *count, c = 1;
if (section->format_header) {
ptr = *(void **)ptr;
count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
} else
count = &c;
if (ptr)
for (i=0; i<*count; i++, ptr += section->size)
for (j=0; section->fields[j].name; j++) {
const ASSFields *field = §ion->fields[j];
if (field->type == ASS_STR)
av_freep(ptr + field->offset);
}
*count = 0;
if (section->format_header)
av_freep((uint8_t *)&ctx->ass + section->offset);
}
ASSDialog *ff_ass_split_dialog(ASSSplitContext *ctx, const char *buf,
int cache, int *number)
{
ASSDialog *dialog = NULL;
int i, count;
if (!cache)
for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
if (!strcmp(ass_sections[i].section, "Events")) {
free_section(ctx, &ass_sections[i]);
break;
}
count = ctx->ass.dialogs_count;
if (ass_split(ctx, buf) == 0)
dialog = ctx->ass.dialogs + count;
if (number)
*number = ctx->ass.dialogs_count - count;
return dialog;
}
void ff_ass_free_dialog(ASSDialog **dialogp)
{
ASSDialog *dialog = *dialogp;
if (!dialog)
return;
av_freep(&dialog->style);
av_freep(&dialog->name);
av_freep(&dialog->effect);
av_freep(&dialog->text);
av_freep(dialogp);
}
ASSDialog *ff_ass_split_dialog2(ASSSplitContext *ctx, const char *buf)
{
int i;
static const ASSFields fields[] = {
{"ReadOrder", ASS_INT, offsetof(ASSDialog, readorder)},
{"Layer", ASS_INT, offsetof(ASSDialog, layer) },
{"Style", ASS_STR, offsetof(ASSDialog, style) },
{"Name", ASS_STR, offsetof(ASSDialog, name) },
{"MarginL", ASS_INT, offsetof(ASSDialog, margin_l) },
{"MarginR", ASS_INT, offsetof(ASSDialog, margin_r) },
{"MarginV", ASS_INT, offsetof(ASSDialog, margin_v) },
{"Effect", ASS_STR, offsetof(ASSDialog, effect) },
{"Text", ASS_STR, offsetof(ASSDialog, text) },
};
ASSDialog *dialog = av_mallocz(sizeof(*dialog));
if (!dialog)
return NULL;
for (i = 0; i < FF_ARRAY_ELEMS(fields); i++) {
size_t len;
const int last = i == FF_ARRAY_ELEMS(fields) - 1;
const ASSFieldType type = fields[i].type;
uint8_t *ptr = (uint8_t *)dialog + fields[i].offset;
buf = skip_space(buf);
len = last ? strlen(buf) : strcspn(buf, ",");
if (len >= INT_MAX) {
ff_ass_free_dialog(&dialog);
return NULL;
}
convert_func[type](ptr, buf, len);
buf += len;
if (*buf) buf++;
}
return dialog;
}
void ff_ass_split_free(ASSSplitContext *ctx)
{
if (ctx) {
int i;
for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++) {
free_section(ctx, &ass_sections[i]);
av_freep(&(ctx->field_order[i]));
}
av_free(ctx);
}
}
int ff_ass_split_override_codes(const ASSCodesCallbacks *callbacks, void *priv,
const char *buf)
{
const char *text = NULL;
char new_line[2];
int text_len = 0;
while (buf && *buf) {
if (text && callbacks->text &&
(sscanf(buf, "\\%1[nN]", new_line) == 1 ||
!strncmp(buf, "{\\", 2))) {
callbacks->text(priv, text, text_len);
text = NULL;
}
if (sscanf(buf, "\\%1[nN]", new_line) == 1) {
if (callbacks->new_line)
callbacks->new_line(priv, new_line[0] == 'N');
buf += 2;
} else if (!strncmp(buf, "{\\", 2)) {
buf++;
while (*buf == '\\') {
char style[2], c[2], sep[2], c_num[2] = "0", tmp[128] = {0};
unsigned int color = 0xFFFFFFFF;
int len, size = -1, an = -1, alpha = -1;
int x1, y1, x2, y2, t1 = -1, t2 = -1;
if (sscanf(buf, "\\%1[bisu]%1[01\\}]%n", style, c, &len) > 1) {
int close = c[0] == '0' ? 1 : c[0] == '1' ? 0 : -1;
len += close != -1;
if (callbacks->style)
callbacks->style(priv, style[0], close);
} else if (sscanf(buf, "\\c%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\c&H%X&%1[\\}]%n", &color, sep, &len) > 1 ||
sscanf(buf, "\\%1[1234]c%1[\\}]%n", c_num, sep, &len) > 1 ||
sscanf(buf, "\\%1[1234]c&H%X&%1[\\}]%n", c_num, &color, sep, &len) > 2) {
if (callbacks->color)
callbacks->color(priv, color, c_num[0] - '0');
} else if (sscanf(buf, "\\alpha%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\alpha&H%2X&%1[\\}]%n", &alpha, sep, &len) > 1 ||
sscanf(buf, "\\%1[1234]a%1[\\}]%n", c_num, sep, &len) > 1 ||
sscanf(buf, "\\%1[1234]a&H%2X&%1[\\}]%n", c_num, &alpha, sep, &len) > 2) {
if (callbacks->alpha)
callbacks->alpha(priv, alpha, c_num[0] - '0');
} else if (sscanf(buf, "\\fn%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\fn%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
if (callbacks->font_name)
callbacks->font_name(priv, tmp[0] ? tmp : NULL);
} else if (sscanf(buf, "\\fs%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\fs%u%1[\\}]%n", &size, sep, &len) > 1) {
if (callbacks->font_size)
callbacks->font_size(priv, size);
} else if (sscanf(buf, "\\a%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\a%2u%1[\\}]%n", &an, sep, &len) > 1 ||
sscanf(buf, "\\an%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\an%1u%1[\\}]%n", &an, sep, &len) > 1) {
if (an != -1 && buf[2] != 'n')
an = (an&3) + (an&4 ? 6 : an&8 ? 3 : 0);
if (callbacks->alignment)
callbacks->alignment(priv, an);
} else if (sscanf(buf, "\\r%1[\\}]%n", sep, &len) > 0 ||
sscanf(buf, "\\r%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
if (callbacks->cancel_overrides)
callbacks->cancel_overrides(priv, tmp);
} else if (sscanf(buf, "\\move(%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, sep, &len) > 4 ||
sscanf(buf, "\\move(%d,%d,%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, &t1, &t2, sep, &len) > 6) {
if (callbacks->move)
callbacks->move(priv, x1, y1, x2, y2, t1, t2);
} else if (sscanf(buf, "\\pos(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
if (callbacks->move)
callbacks->move(priv, x1, y1, x1, y1, -1, -1);
} else if (sscanf(buf, "\\org(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
if (callbacks->origin)
callbacks->origin(priv, x1, y1);
} else {
len = strcspn(buf+1, "\\}") + 2; /* skip unknown code */
}
buf += len - 1;
}
if (*buf++ != '}')
return AVERROR_INVALIDDATA;
} else {
if (!text) {
text = buf;
text_len = 1;
} else
text_len++;
buf++;
}
}
if (text && callbacks->text)
callbacks->text(priv, text, text_len);
if (callbacks->end)
callbacks->end(priv);
return 0;
}
ASSStyle *ff_ass_style_get(ASSSplitContext *ctx, const char *style)
{
ASS *ass = &ctx->ass;
int i;
if (!style || !*style)
style = "Default";
for (i=0; i<ass->styles_count; i++)
if (ass->styles[i].name && !strcmp(ass->styles[i].name, style))
return ass->styles + i;
return NULL;
}
| gpl-3.0 |
UnknownX7/darkstar | scripts/zones/Windurst_Waters_[S]/npcs/Nhel_Urhahn.lua | 1064 | -----------------------------------
-- Area: Windurst Waters (S)
-- NPC: Nhel Urhahn
-- Type: Standard NPC
-- @zone 94
-- @pos -47.348 -4.499 47.117
--
-- Auto-Script: Requires Verification (Verified by Brawndo)
-----------------------------------
package.loaded["scripts/zones/Windurst_Waters_[S]/TextIDs"] = nil;
-----------------------------------
-----------------------------------
-- onTrade Action
-----------------------------------
function onTrade(player,npc,trade)
end;
-----------------------------------
-- onTrigger Action
-----------------------------------
function onTrigger(player,npc)
player:startEvent(0x01a0);
end;
-----------------------------------
-- onEventUpdate
-----------------------------------
function onEventUpdate(player,csid,option)
-- printf("CSID: %u",csid);
-- printf("RESULT: %u",option);
end;
-----------------------------------
-- onEventFinish
-----------------------------------
function onEventFinish(player,csid,option)
-- printf("CSID: %u",csid);
-- printf("RESULT: %u",option);
end;
| gpl-3.0 |
geminy/aidear | oss/cegui/cegui-0.8.7/cegui/src/ScriptModules/Python/bindings/output/CEGUI/DefaultLogger.pypp.cpp | 3612 | // This file has been generated by Py++.
#include "boost/python.hpp"
#include "generators/include/python_CEGUI.h"
#include "DefaultLogger.pypp.hpp"
namespace bp = boost::python;
struct DefaultLogger_wrapper : CEGUI::DefaultLogger, bp::wrapper< CEGUI::DefaultLogger > {
DefaultLogger_wrapper( )
: CEGUI::DefaultLogger( )
, bp::wrapper< CEGUI::DefaultLogger >(){
// null constructor
}
virtual void logEvent( ::CEGUI::String const & message, ::CEGUI::LoggingLevel level=::CEGUI::Standard ) {
if( bp::override func_logEvent = this->get_override( "logEvent" ) )
func_logEvent( boost::ref(message), level );
else{
this->CEGUI::DefaultLogger::logEvent( boost::ref(message), level );
}
}
void default_logEvent( ::CEGUI::String const & message, ::CEGUI::LoggingLevel level=::CEGUI::Standard ) {
CEGUI::DefaultLogger::logEvent( boost::ref(message), level );
}
virtual void setLogFilename( ::CEGUI::String const & filename, bool append=false ) {
if( bp::override func_setLogFilename = this->get_override( "setLogFilename" ) )
func_setLogFilename( boost::ref(filename), append );
else{
this->CEGUI::DefaultLogger::setLogFilename( boost::ref(filename), append );
}
}
void default_setLogFilename( ::CEGUI::String const & filename, bool append=false ) {
CEGUI::DefaultLogger::setLogFilename( boost::ref(filename), append );
}
};
void register_DefaultLogger_class(){
{ //::CEGUI::DefaultLogger
typedef bp::class_< DefaultLogger_wrapper, bp::bases< CEGUI::Logger >, boost::noncopyable > DefaultLogger_exposer_t;
DefaultLogger_exposer_t DefaultLogger_exposer = DefaultLogger_exposer_t( "DefaultLogger", "*!\n\
\n\
Default implementation for the Logger class.\n\
If you want to redirect CEGUI logs to some place other than a text file,\n\
implement your own Logger implementation and create a object of the\n\
Logger type before creating the CEGUI.System singleton.\n\
*\n", bp::no_init );
bp::scope DefaultLogger_scope( DefaultLogger_exposer );
DefaultLogger_exposer.def( bp::init< >() );
{ //::CEGUI::DefaultLogger::logEvent
typedef void ( ::CEGUI::DefaultLogger::*logEvent_function_type )( ::CEGUI::String const &,::CEGUI::LoggingLevel ) ;
typedef void ( DefaultLogger_wrapper::*default_logEvent_function_type )( ::CEGUI::String const &,::CEGUI::LoggingLevel ) ;
DefaultLogger_exposer.def(
"logEvent"
, logEvent_function_type(&::CEGUI::DefaultLogger::logEvent)
, default_logEvent_function_type(&DefaultLogger_wrapper::default_logEvent)
, ( bp::arg("message"), bp::arg("level")=::CEGUI::Standard ) );
}
{ //::CEGUI::DefaultLogger::setLogFilename
typedef void ( ::CEGUI::DefaultLogger::*setLogFilename_function_type )( ::CEGUI::String const &,bool ) ;
typedef void ( DefaultLogger_wrapper::*default_setLogFilename_function_type )( ::CEGUI::String const &,bool ) ;
DefaultLogger_exposer.def(
"setLogFilename"
, setLogFilename_function_type(&::CEGUI::DefaultLogger::setLogFilename)
, default_setLogFilename_function_type(&DefaultLogger_wrapper::default_setLogFilename)
, ( bp::arg("filename"), bp::arg("append")=(bool)(false) ) );
}
}
}
| gpl-3.0 |
the7day/sumatrapdf | src/Favorites.cpp | 27609 | /* Copyright 2015 the SumatraPDF project authors (see AUTHORS file).
License: GPLv3 */
// utils
#include "BaseUtil.h"
#include "Dpi.h"
#include "FileUtil.h"
#include "GdiPlusUtil.h"
#include "LabelWithCloseWnd.h"
#include "UITask.h"
#include "WinUtil.h"
// rendering engines
#include "BaseEngine.h"
#include "EngineManager.h"
// layout controllers
#include "SettingsStructs.h"
#include "Controller.h"
#include "FileHistory.h"
#include "GlobalPrefs.h"
// ui
#include "SumatraPDF.h"
#include "WindowInfo.h"
#include "TabInfo.h"
#include "resource.h"
#include "AppPrefs.h"
#include "Favorites.h"
#include "Menu.h"
#include "SumatraDialogs.h"
#include "Tabs.h"
#include "Translations.h"
Favorite *Favorites::GetByMenuId(int menuId, DisplayState **dsOut)
{
DisplayState *ds;
for (size_t i = 0; (ds = gFileHistory.Get(i)) != nullptr; i++) {
for (size_t j = 0; j < ds->favorites->Count(); j++) {
if (menuId == ds->favorites->At(j)->menuId) {
if (dsOut)
*dsOut = ds;
return ds->favorites->At(j);
}
}
}
return nullptr;
}
DisplayState *Favorites::GetByFavorite(Favorite *fn)
{
DisplayState *ds;
for (size_t i = 0; (ds = gFileHistory.Get(i)) != nullptr; i++) {
if (ds->favorites->Contains(fn))
return ds;
}
return nullptr;
}
void Favorites::ResetMenuIds()
{
DisplayState *ds;
for (size_t i = 0; (ds = gFileHistory.Get(i)) != nullptr; i++) {
for (size_t j = 0; j < ds->favorites->Count(); j++) {
ds->favorites->At(j)->menuId = 0;
}
}
}
DisplayState *Favorites::GetFavByFilePath(const WCHAR *filePath)
{
// it's likely that we'll ask about the info for the same
// file as in previous call, so use one element cache
DisplayState *ds = gFileHistory.Get(idxCache);
if (!ds || !str::Eq(ds->filePath, filePath))
ds = gFileHistory.Find(filePath, &idxCache);
return ds;
}
bool Favorites::IsPageInFavorites(const WCHAR *filePath, int pageNo)
{
DisplayState *fav = GetFavByFilePath(filePath);
if (!fav)
return false;
for (size_t i = 0; i < fav->favorites->Count(); i++) {
if (pageNo == fav->favorites->At(i)->pageNo)
return true;
}
return false;
}
static Favorite *FindByPage(DisplayState *ds, int pageNo, const WCHAR *pageLabel=nullptr)
{
if (pageLabel) {
for (size_t i = 0; i < ds->favorites->Count(); i++) {
if (str::Eq(ds->favorites->At(i)->pageLabel, pageLabel))
return ds->favorites->At(i);
}
}
for (size_t i = 0; i < ds->favorites->Count(); i++) {
if (pageNo == ds->favorites->At(i)->pageNo)
return ds->favorites->At(i);
}
return nullptr;
}
static int SortByPageNo(const void *a, const void *b)
{
Favorite *na = *(Favorite **)a;
Favorite *nb = *(Favorite **)b;
// sort lower page numbers first
return na->pageNo - nb->pageNo;
}
void Favorites::AddOrReplace(const WCHAR *filePath, int pageNo, const WCHAR *name, const WCHAR *pageLabel)
{
DisplayState *fav = GetFavByFilePath(filePath);
if (!fav) {
CrashIf(gGlobalPrefs->rememberOpenedFiles);
fav = NewDisplayState(filePath);
gFileHistory.Append(fav);
}
Favorite *fn = FindByPage(fav, pageNo, pageLabel);
if (fn) {
str::ReplacePtr(&fn->name, name);
CrashIf(fn->pageLabel && !str::Eq(fn->pageLabel, pageLabel));
}
else {
fn = NewFavorite(pageNo, name, pageLabel);
fav->favorites->Append(fn);
fav->favorites->Sort(SortByPageNo);
}
}
void Favorites::Remove(const WCHAR *filePath, int pageNo)
{
DisplayState *fav = GetFavByFilePath(filePath);
if (!fav)
return;
Favorite *fn = FindByPage(fav, pageNo);
if (!fn)
return;
fav->favorites->Remove(fn);
DeleteFavorite(fn);
if (!gGlobalPrefs->rememberOpenedFiles && 0 == fav->favorites->Count()) {
gFileHistory.Remove(fav);
DeleteDisplayState(fav);
}
}
void Favorites::RemoveAllForFile(const WCHAR *filePath)
{
DisplayState *fav = GetFavByFilePath(filePath);
if (!fav)
return;
for (size_t i = 0; i < fav->favorites->Count(); i++) {
DeleteFavorite(fav->favorites->At(i));
}
fav->favorites->Reset();
if (!gGlobalPrefs->rememberOpenedFiles) {
gFileHistory.Remove(fav);
DeleteDisplayState(fav);
}
}
// Note: those might be too big
#define MAX_FAV_SUBMENUS 10
#define MAX_FAV_MENUS 10
MenuDef menuDefFavContext[] = {
{ _TRN("Remove from favorites"), IDM_FAV_DEL, 0 }
};
static bool HasFavorites()
{
DisplayState *ds;
for (size_t i = 0; (ds = gFileHistory.Get(i)) != nullptr; i++) {
if (ds->favorites->Count() > 0)
return true;
}
return false;
}
// caller has to free() the result
static WCHAR *FavReadableName(Favorite *fn)
{
ScopedMem<WCHAR> plainLabel(str::Format(L"%d", fn->pageNo));
const WCHAR *label = fn->pageLabel ? fn->pageLabel : plainLabel;
if (fn->name) {
ScopedMem<WCHAR> pageNo(str::Format(_TR("(page %s)"), label));
return str::Join(fn->name, L" ", pageNo);
}
return str::Format(_TR("Page %s"), label);
}
// caller has to free() the result
static WCHAR *FavCompactReadableName(DisplayState *fav, Favorite *fn, bool isCurrent=false)
{
ScopedMem<WCHAR> rn(FavReadableName(fn));
if (isCurrent)
return str::Format(L"%s : %s", _TR("Current file"), rn.Get());
const WCHAR *fp = path::GetBaseName(fav->filePath);
return str::Format(L"%s : %s", fp, rn.Get());
}
static void AppendFavMenuItems(HMENU m, DisplayState *f, UINT& idx, bool combined, bool isCurrent)
{
for (size_t i = 0; i < f->favorites->Count(); i++) {
if (i >= MAX_FAV_MENUS)
return;
Favorite *fn = f->favorites->At(i);
fn->menuId = idx++;
ScopedMem<WCHAR> s;
if (combined)
s.Set(FavCompactReadableName(f, fn, isCurrent));
else
s.Set(FavReadableName(fn));
AppendMenu(m, MF_STRING, (UINT_PTR)fn->menuId, win::menu::ToSafeString(s, s));
}
}
static int SortByBaseFileName(const void *a, const void *b)
{
const WCHAR *filePathA = *(const WCHAR **)a;
const WCHAR *filePathB = *(const WCHAR **)b;
return str::CmpNatural(path::GetBaseName(filePathA), path::GetBaseName(filePathB));
}
static void GetSortedFilePaths(Vec<const WCHAR *>& filePathsSortedOut, DisplayState *toIgnore=nullptr)
{
DisplayState *ds;
for (size_t i = 0; (ds = gFileHistory.Get(i)) != nullptr; i++) {
if (ds->favorites->Count() > 0 && ds != toIgnore)
filePathsSortedOut.Append(ds->filePath);
}
filePathsSortedOut.Sort(SortByBaseFileName);
}
// For easy access, we try to show favorites in the menu, similar to a list of
// recently opened files.
// The first menu items are for currently opened file (up to MAX_FAV_MENUS), based
// on the assumption that user is usually interested in navigating current file.
// Then we have a submenu for each file for which there are bookmarks (up to
// MAX_FAV_SUBMENUS), each having up to MAX_FAV_MENUS menu items.
// If not all favorites can be shown, we also enable "Show all favorites" menu which
// will provide a way to see all favorites.
// Note: not sure if that's the best layout. Maybe we should always use submenu and
// put the submenu for current file as the first one (potentially named as "Current file"
// or some such, to make it stand out from other submenus)
static void AppendFavMenus(HMENU m, const WCHAR *currFilePath)
{
// To minimize mouse movement when navigating current file via favorites
// menu, put favorites for current file first
DisplayState *currFileFav = nullptr;
if (currFilePath) {
currFileFav = gFavorites.GetFavByFilePath(currFilePath);
}
// sort the files with favorites by base file name of file path
Vec<const WCHAR *> filePathsSorted;
if (HasPermission(Perm_DiskAccess)) {
// only show favorites for other files, if we're allowed to open them
GetSortedFilePaths(filePathsSorted, currFileFav);
}
if (currFileFav && currFileFav->favorites->Count() > 0)
filePathsSorted.InsertAt(0, currFileFav->filePath);
if (filePathsSorted.Count() == 0)
return;
AppendMenu(m, MF_SEPARATOR, 0, nullptr);
gFavorites.ResetMenuIds();
UINT menuId = IDM_FAV_FIRST;
size_t menusCount = filePathsSorted.Count();
if (menusCount > MAX_FAV_MENUS)
menusCount = MAX_FAV_MENUS;
for (size_t i = 0; i < menusCount; i++) {
const WCHAR *filePath = filePathsSorted.At(i);
DisplayState *f = gFavorites.GetFavByFilePath(filePath);
CrashIf(!f);
HMENU sub = m;
bool combined = (f->favorites->Count() == 1);
if (!combined)
sub = CreateMenu();
AppendFavMenuItems(sub, f, menuId, combined, f == currFileFav);
if (!combined) {
if (f == currFileFav) {
AppendMenu(m, MF_POPUP | MF_STRING, (UINT_PTR)sub, _TR("Current file"));
} else {
ScopedMem<WCHAR> tmp;
const WCHAR *fileName = win::menu::ToSafeString(path::GetBaseName(filePath), tmp);
AppendMenu(m, MF_POPUP | MF_STRING, (UINT_PTR)sub, fileName);
}
}
}
}
// Called when a user opens "Favorites" top-level menu. We need to construct
// the menu:
// - disable add/remove menu items if no document is opened
// - if a document is opened and the page is already bookmarked,
// disable "add" menu item and enable "remove" menu item
// - if a document is opened and the page is not bookmarked,
// enable "add" menu item and disable "remove" menu item
void RebuildFavMenu(WindowInfo *win, HMENU menu)
{
if (!win->IsDocLoaded()) {
win::menu::SetEnabled(menu, IDM_FAV_ADD, false);
win::menu::SetEnabled(menu, IDM_FAV_DEL, false);
AppendFavMenus(menu, nullptr);
} else {
ScopedMem<WCHAR> label(win->ctrl->GetPageLabel(win->currPageNo));
bool isBookmarked = gFavorites.IsPageInFavorites(win->ctrl->FilePath(), win->currPageNo);
if (isBookmarked) {
win::menu::SetEnabled(menu, IDM_FAV_ADD, false);
ScopedMem<WCHAR> s(str::Format(_TR("Remove page %s from favorites"), label.Get()));
win::menu::SetText(menu, IDM_FAV_DEL, s);
} else {
win::menu::SetEnabled(menu, IDM_FAV_DEL, false);
ScopedMem<WCHAR> s(str::Format(_TR("Add page %s to favorites"), label.Get()));
win::menu::SetText(menu, IDM_FAV_ADD, s);
}
AppendFavMenus(menu, win->ctrl->FilePath());
}
win::menu::SetEnabled(menu, IDM_FAV_TOGGLE, HasFavorites());
}
void ToggleFavorites(WindowInfo *win)
{
if (gGlobalPrefs->showFavorites) {
SetSidebarVisibility(win, win->tocVisible, false);
} else {
SetSidebarVisibility(win, win->tocVisible, true);
SetFocus(win->hwndFavTree);
}
}
static void GoToFavorite(WindowInfo *win, int pageNo) {
if (!WindowInfoStillValid(win))
return;
if (win->IsDocLoaded() && win->ctrl->ValidPageNo(pageNo))
win->ctrl->GoToPage(pageNo, true);
// we might have been invoked by clicking on a tree view
// switch focus so that keyboard navigation works, which enables
// a fluid experience
win->Focus();
}
// Going to a bookmark within current file scrolls to a given page.
// Going to a bookmark in another file, loads the file and scrolls to a page
// (similar to how invoking one of the recently opened files works)
static void GoToFavorite(WindowInfo *win, DisplayState *f, Favorite *fn)
{
assert(f && fn);
if (!f || !fn) return;
WindowInfo *existingWin = FindWindowInfoByFile(f->filePath, true);
if (existingWin) {
int pageNo = fn->pageNo;
uitask::Post([=] { GoToFavorite(existingWin, pageNo); });
return;
}
if (!HasPermission(Perm_DiskAccess))
return;
// When loading a new document, go directly to selected page instead of
// first showing last seen page stored in file history
// A hacky solution because I don't want to add even more parameters to
// LoadDocument() and LoadDocumentInto()
int pageNo = fn->pageNo;
DisplayState *ds = gFileHistory.Find(f->filePath);
if (ds && !ds->useDefaultState && gGlobalPrefs->rememberStatePerDocument) {
ds->pageNo = fn->pageNo;
ds->scrollPos = PointI(-1, -1); // don't scroll the page
pageNo = -1;
}
LoadArgs args(f->filePath, win);
win = LoadDocument(args);
if (win) {
uitask::Post([=] { (win, pageNo); });
}
}
void GoToFavoriteByMenuId(WindowInfo *win, int wmId)
{
DisplayState *f;
Favorite *fn = gFavorites.GetByMenuId(wmId, &f);
if (fn)
GoToFavorite(win, f, fn);
}
static void GoToFavForTVItem(WindowInfo* win, HWND hTV, HTREEITEM hItem=nullptr)
{
if (nullptr == hItem)
hItem = TreeView_GetSelection(hTV);
TVITEM item;
item.hItem = hItem;
item.mask = TVIF_PARAM;
TreeView_GetItem(hTV, &item);
Favorite *fn = (Favorite *)item.lParam;
if (!fn) {
// can happen for top-level node which is not associated with a favorite
// but only serves a parent node for favorites for a given file
return;
}
DisplayState *f = gFavorites.GetByFavorite(fn);
GoToFavorite(win, f, fn);
}
static HTREEITEM InsertFavSecondLevelNode(HWND hwnd, HTREEITEM parent, Favorite *fn)
{
TV_INSERTSTRUCT tvinsert;
tvinsert.hParent = parent;
tvinsert.hInsertAfter = TVI_LAST;
tvinsert.itemex.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
tvinsert.itemex.state = 0;
tvinsert.itemex.stateMask = TVIS_EXPANDED;
tvinsert.itemex.lParam = (LPARAM)fn;
ScopedMem<WCHAR> s(FavReadableName(fn));
tvinsert.itemex.pszText = s;
return TreeView_InsertItem(hwnd, &tvinsert);
}
static void InsertFavSecondLevelNodes(HWND hwnd, HTREEITEM parent, DisplayState *f)
{
for (size_t i = 0; i < f->favorites->Count(); i++) {
InsertFavSecondLevelNode(hwnd, parent, f->favorites->At(i));
}
}
static HTREEITEM InsertFavTopLevelNode(HWND hwnd, DisplayState *fav, bool isExpanded)
{
WCHAR *s = nullptr;
bool collapsed = fav->favorites->Count() == 1;
if (collapsed)
isExpanded = false;
TV_INSERTSTRUCT tvinsert;
tvinsert.hParent = nullptr;
tvinsert.hInsertAfter = TVI_LAST;
tvinsert.itemex.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
tvinsert.itemex.state = isExpanded ? TVIS_EXPANDED : 0;
tvinsert.itemex.stateMask = TVIS_EXPANDED;
tvinsert.itemex.lParam = 0;
if (collapsed) {
Favorite *fn = fav->favorites->At(0);
tvinsert.itemex.lParam = (LPARAM)fn;
s = FavCompactReadableName(fav, fn);
tvinsert.itemex.pszText = s;
} else {
tvinsert.itemex.pszText = (WCHAR*)path::GetBaseName(fav->filePath);
}
HTREEITEM ret = TreeView_InsertItem(hwnd, &tvinsert);
free(s);
return ret;
}
void PopulateFavTreeIfNeeded(WindowInfo *win)
{
HWND hwndTree = win->hwndFavTree;
if (TreeView_GetCount(hwndTree) > 0)
return;
Vec<const WCHAR *> filePathsSorted;
GetSortedFilePaths(filePathsSorted);
SendMessage(hwndTree, WM_SETREDRAW, FALSE, 0);
for (size_t i = 0; i < filePathsSorted.Count(); i++) {
DisplayState *f = gFavorites.GetFavByFilePath(filePathsSorted.At(i));
bool isExpanded = win->expandedFavorites.Contains(f);
HTREEITEM node = InsertFavTopLevelNode(hwndTree, f, isExpanded);
if (f->favorites->Count() > 1)
InsertFavSecondLevelNodes(hwndTree, node, f);
}
SendMessage(hwndTree, WM_SETREDRAW, TRUE, 0);
UINT fl = RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN;
RedrawWindow(hwndTree, nullptr, nullptr, fl);
}
void UpdateFavoritesTree(WindowInfo *win)
{
HWND hwndTree = win->hwndFavTree;
if (TreeView_GetCount(hwndTree) > 0) {
// PopulateFavTreeIfNeeded will re-enable WM_SETREDRAW
SendMessage(hwndTree, WM_SETREDRAW, FALSE, 0);
TreeView_DeleteAllItems(hwndTree);
PopulateFavTreeIfNeeded(win);
}
// hide the favorites tree if we've removed the last favorite
if (0 == TreeView_GetCount(hwndTree)) {
SetSidebarVisibility(win, win->tocVisible, false);
}
}
void UpdateFavoritesTreeForAllWindows()
{
for (WindowInfo *win : gWindows) {
UpdateFavoritesTree(win);
}
}
static DocTocItem *TocItemForPageNo(DocTocItem *item, int pageNo)
{
DocTocItem *currItem = nullptr;
for (; item; item = item->next) {
if (1 <= item->pageNo && item->pageNo <= pageNo)
currItem = item;
if (item->pageNo >= pageNo)
break;
// find any child item closer to the specified page
DocTocItem *subItem = TocItemForPageNo(item->child, pageNo);
if (subItem)
currItem = subItem;
}
return currItem;
}
void AddFavorite(WindowInfo *win)
{
TabInfo *tab = win->currentTab;
CrashIf(!tab);
int pageNo = win->currPageNo;
ScopedMem<WCHAR> name;
if (tab->ctrl->HasTocTree()) {
// use the current ToC heading as default name
DocTocItem *root = tab->ctrl->GetTocTree();
DocTocItem *item = TocItemForPageNo(root, pageNo);
if (item)
name.Set(str::Dup(item->title));
delete root;
}
ScopedMem<WCHAR> pageLabel(tab->ctrl->GetPageLabel(pageNo));
bool shouldAdd = Dialog_AddFavorite(win->hwndFrame, pageLabel, name);
if (!shouldAdd)
return;
ScopedMem<WCHAR> plainLabel(str::Format(L"%d", pageNo));
bool needsLabel = !str::Eq(plainLabel, pageLabel);
RememberFavTreeExpansionStateForAllWindows();
gFavorites.AddOrReplace(tab->filePath, pageNo, name, needsLabel ? pageLabel.Get() : nullptr);
// expand newly added favorites by default
DisplayState *fav = gFavorites.GetFavByFilePath(tab->filePath);
if (fav && fav->favorites->Count() == 2)
win->expandedFavorites.Append(fav);
UpdateFavoritesTreeForAllWindows();
prefs::Save();
}
void DelFavorite(WindowInfo *win)
{
CrashIf(!win->currentTab);
RememberFavTreeExpansionStateForAllWindows();
gFavorites.Remove(win->currentTab->filePath, win->currPageNo);
UpdateFavoritesTreeForAllWindows();
prefs::Save();
}
void RememberFavTreeExpansionState(WindowInfo *win)
{
win->expandedFavorites.Reset();
HTREEITEM treeItem = TreeView_GetRoot(win->hwndFavTree);
while (treeItem) {
TVITEM item;
item.hItem = treeItem;
item.mask = TVIF_PARAM | TVIF_STATE;
item.stateMask = TVIS_EXPANDED;
TreeView_GetItem(win->hwndFavTree, &item);
if ((item.state & TVIS_EXPANDED) != 0) {
item.hItem = TreeView_GetChild(win->hwndFavTree, treeItem);
item.mask = TVIF_PARAM;
TreeView_GetItem(win->hwndFavTree, &item);
Favorite *fn = (Favorite *)item.lParam;
DisplayState *f = gFavorites.GetByFavorite(fn);
win->expandedFavorites.Append(f);
}
treeItem = TreeView_GetNextSibling(win->hwndFavTree, treeItem);
}
}
void RememberFavTreeExpansionStateForAllWindows()
{
for (size_t i = 0; i < gWindows.Count(); i++) {
RememberFavTreeExpansionState(gWindows.At(i));
}
}
static LRESULT OnFavTreeNotify(WindowInfo *win, LPNMTREEVIEW pnmtv)
{
switch (pnmtv->hdr.code)
{
// TVN_SELCHANGED intentionally not implemented (mouse clicks are handled
// in NM_CLICK, and keyboard navigation in NM_RETURN and TVN_KEYDOWN)
case TVN_KEYDOWN: {
TV_KEYDOWN *ptvkd = (TV_KEYDOWN *)pnmtv;
if (VK_TAB == ptvkd->wVKey) {
if (win->tabsVisible && IsCtrlPressed())
TabsOnCtrlTab(win, IsShiftPressed());
else
AdvanceFocus(win);
return 1;
}
break;
}
case NM_CLICK: {
// Determine which item has been clicked (if any)
TVHITTESTINFO ht = { 0 };
DWORD pos = GetMessagePos();
ht.pt.x = GET_X_LPARAM(pos);
ht.pt.y = GET_Y_LPARAM(pos);
MapWindowPoints(HWND_DESKTOP, pnmtv->hdr.hwndFrom, &ht.pt, 1);
TreeView_HitTest(pnmtv->hdr.hwndFrom, &ht);
if ((ht.flags & TVHT_ONITEM))
GoToFavForTVItem(win, pnmtv->hdr.hwndFrom, ht.hItem);
break;
}
case NM_RETURN:
GoToFavForTVItem(win, pnmtv->hdr.hwndFrom);
break;
case NM_CUSTOMDRAW:
return CDRF_DODEFAULT;
}
return -1;
}
static void OnFavTreeContextMenu(WindowInfo *win, PointI pt)
{
TVITEM item;
if (pt.x != -1 || pt.y != -1) {
TVHITTESTINFO ht = { 0 };
ht.pt.x = pt.x;
ht.pt.y = pt.y;
MapWindowPoints(HWND_DESKTOP, win->hwndFavTree, &ht.pt, 1);
TreeView_HitTest(win->hwndFavTree, &ht);
if ((ht.flags & TVHT_ONITEM) == 0)
return; // only display menu if over a node in tree
TreeView_SelectItem(win->hwndFavTree, ht.hItem);
item.hItem = ht.hItem;
}
else {
item.hItem = TreeView_GetSelection(win->hwndFavTree);
if (!item.hItem)
return;
RECT rcItem;
if (TreeView_GetItemRect(win->hwndFavTree, item.hItem, &rcItem, TRUE)) {
MapWindowPoints(win->hwndFavTree, HWND_DESKTOP, (POINT *)&rcItem, 2);
pt.x = rcItem.left;
pt.y = rcItem.bottom;
}
else {
WindowRect rc(win->hwndFavTree);
pt = rc.TL();
}
}
item.mask = TVIF_PARAM;
TreeView_GetItem(win->hwndFavTree, &item);
Favorite *toDelete = (Favorite *)item.lParam;
HMENU popup = BuildMenuFromMenuDef(menuDefFavContext, dimof(menuDefFavContext), CreatePopupMenu());
INT cmd = TrackPopupMenu(popup, TPM_RETURNCMD | TPM_RIGHTBUTTON,
pt.x, pt.y, 0, win->hwndFavTree, nullptr);
DestroyMenu(popup);
if (IDM_FAV_DEL == cmd) {
RememberFavTreeExpansionStateForAllWindows();
if (toDelete) {
DisplayState *f = gFavorites.GetByFavorite(toDelete);
gFavorites.Remove(f->filePath, toDelete->pageNo);
} else {
// toDelete == nullptr => this is a parent node signifying all bookmarks in a file
item.hItem = TreeView_GetChild(win->hwndFavTree, item.hItem);
item.mask = TVIF_PARAM;
TreeView_GetItem(win->hwndFavTree, &item);
toDelete = (Favorite *)item.lParam;
DisplayState *f = gFavorites.GetByFavorite(toDelete);
gFavorites.RemoveAllForFile(f->filePath);
}
UpdateFavoritesTreeForAllWindows();
prefs::Save();
// TODO: it would be nice to have a system for undo-ing things, like in Gmail,
// so that we can do destructive operations without asking for permission via
// invasive model dialog boxes but also allow reverting them if were done
// by mistake
}
}
static WNDPROC DefWndProcFavTree = nullptr;
static LRESULT CALLBACK WndProcFavTree(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
WindowInfo *win = FindWindowInfoByHwnd(hwnd);
if (!win)
return CallWindowProc(DefWndProcFavTree, hwnd, msg, wParam, lParam);
switch (msg) {
case WM_ERASEBKGND:
return FALSE;
case WM_CHAR:
if (VK_ESCAPE == wParam && gGlobalPrefs->escToExit && MayCloseWindow(win))
CloseWindow(win, true);
break;
case WM_MOUSEWHEEL:
case WM_MOUSEHWHEEL:
// scroll the canvas if the cursor isn't over the ToC tree
if (!IsCursorOverWindow(win->hwndFavTree))
return SendMessage(win->hwndCanvas, msg, wParam, lParam);
break;
}
return CallWindowProc(DefWndProcFavTree, hwnd, msg, wParam, lParam);
}
static WNDPROC DefWndProcFavBox = nullptr;
static LRESULT CALLBACK WndProcFavBox(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
WindowInfo *win = FindWindowInfoByHwnd(hwnd);
if (!win)
return CallWindowProc(DefWndProcFavBox, hwnd, message, wParam, lParam);
switch (message) {
case WM_SIZE:
LayoutTreeContainer(win->favLabelWithClose, win->hwndFavTree);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_FAV_LABEL_WITH_CLOSE)
ToggleFavorites(win);
break;
case WM_NOTIFY:
if (LOWORD(wParam) == IDC_FAV_TREE) {
LPNMTREEVIEW pnmtv = (LPNMTREEVIEW) lParam;
LRESULT res = OnFavTreeNotify(win, pnmtv);
if (res != -1)
return res;
}
break;
case WM_CONTEXTMENU:
if (win->hwndFavTree == (HWND)wParam) {
OnFavTreeContextMenu(win, PointI(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
return 0;
}
break;
}
return CallWindowProc(DefWndProcFavBox, hwnd, message, wParam, lParam);
}
void CreateFavorites(WindowInfo *win)
{
win->hwndFavBox = CreateWindow(WC_STATIC, L"", WS_CHILD|WS_CLIPCHILDREN,
0, 0, gGlobalPrefs->sidebarDx, 0,
win->hwndFrame, (HMENU)0, GetModuleHandle(nullptr), nullptr);
LabelWithCloseWnd *l = CreateLabelWithCloseWnd(win->hwndFavBox, IDC_FAV_LABEL_WITH_CLOSE);
win->favLabelWithClose = l;
SetPaddingXY(l, 2, 2);
SetFont(l, GetDefaultGuiFont());
// label is set in UpdateToolbarSidebarText()
win->hwndFavTree = CreateWindowEx(WS_EX_STATICEDGE, WC_TREEVIEW, L"Fav",
TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_SHOWSELALWAYS|
TVS_TRACKSELECT|TVS_DISABLEDRAGDROP|TVS_NOHSCROLL|TVS_INFOTIP|
WS_TABSTOP|WS_VISIBLE|WS_CHILD,
0, 0, 0, 0, win->hwndFavBox, (HMENU)IDC_FAV_TREE, GetModuleHandle(nullptr), nullptr);
TreeView_SetUnicodeFormat(win->hwndFavTree, true);
if (nullptr == DefWndProcFavTree)
DefWndProcFavTree = (WNDPROC)GetWindowLongPtr(win->hwndFavTree, GWLP_WNDPROC);
SetWindowLongPtr(win->hwndFavTree, GWLP_WNDPROC, (LONG_PTR)WndProcFavTree);
if (nullptr == DefWndProcFavBox)
DefWndProcFavBox = (WNDPROC)GetWindowLongPtr(win->hwndFavBox, GWLP_WNDPROC);
SetWindowLongPtr(win->hwndFavBox, GWLP_WNDPROC, (LONG_PTR)WndProcFavBox);
}
| gpl-3.0 |
arcemu/arcemu | src/world/Map/MapScriptInterface.h | 3521 | /*
* ArcEmu MMORPG Server
* Copyright (C) 2005-2007 Ascent Team <http://www.ascentemu.com/>
* Copyright (C) 2008-2012 <http://www.ArcEmu.org/>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef _MAP_SCRIPT_INTERFACE_H
#define _MAP_SCRIPT_INTERFACE_H
/* * Class MapScriptInterface
* Provides an interface to mapmgr for scripts, to obtain objects,
* get players, etc.
*/
class GameObject;
class Object;
class Creature;
class Unit;
class Player;
class SERVER_DECL MapScriptInterface
{
public:
MapScriptInterface(MapMgr & mgr);
~MapScriptInterface();
template<class T, uint32 TypeId> T* GetObjectNearestCoords(uint32 Entry, float x, float y, float z = 0.0f)
{
MapCell* pCell = mapMgr.GetCell(mapMgr.GetPosX(x), mapMgr.GetPosY(y));
if(pCell == 0)
return 0;
T* ClosestObject = NULL;
float ClosestDist = 999999.0f;
float CurrentDist = 0;
ObjectSet::const_iterator iter = pCell->Begin();
for(; iter != pCell->End(); ++iter)
{
CurrentDist = (*iter)->CalcDistance(x, y, (z != 0.0f ? z : (*iter)->GetPositionZ()));
if(CurrentDist < ClosestDist && (*iter)->GetTypeId() == TypeId)
{
if((Entry && (*iter)->GetEntry() == Entry) || !Entry)
{
ClosestDist = CurrentDist;
ClosestObject = ((T*)(*iter));
}
}
}
return ClosestObject;
}
ARCEMU_INLINE GameObject* GetGameObjectNearestCoords(float x, float y, float z = 0.0f, uint32 Entry = 0)
{
return GetObjectNearestCoords<GameObject, TYPEID_GAMEOBJECT>(Entry, x, y, z);
}
ARCEMU_INLINE Creature* GetCreatureNearestCoords(float x, float y, float z = 0.0f, uint32 Entry = 0)
{
return GetObjectNearestCoords<Creature, TYPEID_UNIT>(Entry, x, y, z);
}
ARCEMU_INLINE Player* GetPlayerNearestCoords(float x, float y, float z = 0.0f, uint32 Entry = 0)
{
return GetObjectNearestCoords<Player, TYPEID_PLAYER>(Entry, x, y, z);
}
uint32 GetPlayerCountInRadius(float x, float y, float z = 0.0f, float radius = 5.0f);
GameObject* SpawnGameObject(uint32 Entry, float cX, float cY, float cZ, float cO, bool AddToWorld, uint32 Misc1, uint32 Misc2, uint32 phase = 0xFFFFFFF);
GameObject* SpawnGameObject(GOSpawn* gs, bool AddToWorld);
Creature* SpawnCreature(uint32 Entry, float cX, float cY, float cZ, float cO, bool AddToWorld, bool tmplate, uint32 Misc1, uint32 Misc2, uint32 phase = 0xFFFFFFF);
Creature* SpawnCreature(CreatureSpawn* sp, bool AddToWorld);
WayPoint* CreateWaypoint();
void DeleteGameObject(GameObject* ptr);
void DeleteCreature(Creature* ptr);
MapScriptInterface & operator=(MapScriptInterface & msi)
{
if(this != &msi)
{
this->mapMgr = msi.mapMgr;
}
return *this;
}
private:
MapMgr & mapMgr;
};
class SERVER_DECL StructFactory : public Singleton<StructFactory>
{
public:
StructFactory() {}
WayPoint* CreateWaypoint();
};
#define sStructFactory StructFactory::getSingleton()
#endif
| agpl-3.0 |
AydinSakar/sql-layer | src/test/resources/com/foundationdb/sql/optimizer/operator/coia-group-index/select-17bu.sql | 243 | SELECT customers.name, items.quan
FROM customers, orders, items, addresses
WHERE customers.cid = orders.cid
AND orders.oid = items.oid
AND customers.cid = addresses.cid
AND addresses.state IN ('MA', 'NY', 'VT')
ORDER BY quan DESC
| agpl-3.0 |
jochenvdv/checkstyle | src/test/resources/com/puppycrawl/tools/checkstyle/checks/indentation/indentation/InputIndentationInvalidWhileIndent.java | 4344 | package com.puppycrawl.tools.checkstyle.checks.indentation.indentation; //indent:0 exp:0
/** //indent:0 exp:0
* This test-input is intended to be checked using following configuration: //indent:1 exp:1
* //indent:1 exp:1
* arrayInitIndent = 4 //indent:1 exp:1
* basicOffset = 4 //indent:1 exp:1
* braceAdjustment = 0 //indent:1 exp:1
* caseIndent = 4 //indent:1 exp:1
* forceStrictCondition = false //indent:1 exp:1
* lineWrappingIndentation = 4 //indent:1 exp:1
* tabWidth = 4 //indent:1 exp:1
* throwsIndent = 4 //indent:1 exp:1
* //indent:1 exp:1
* @author jrichard //indent:1 exp:1
*/ //indent:1 exp:1
public class InputIndentationInvalidWhileIndent { //indent:0 exp:0
/** Creates a new instance of InputIndentationValidWhileIndent */ //indent:4 exp:4
public InputIndentationInvalidWhileIndent() { //indent:4 exp:4
} //indent:4 exp:4
private void method1() //indent:4 exp:4
{ //indent:4 exp:4
boolean test = true; //indent:8 exp:8
while (test) { //indent:9 exp:8 warn
} //indent:7 exp:8 warn
while (test) //indent:7 exp:8 warn
{ //indent:9 exp:8 warn
} //indent:9 exp:8 warn
while (test) //indent:9 exp:8 warn
{ //indent:6 exp:8 warn
System.getProperty("foo"); //indent:14 exp:12 warn
} //indent:6 exp:8 warn
while (test) { //indent:10 exp:8 warn
System.getProperty("foo"); //indent:12 exp:12
} //indent:10 exp:8 warn
while (test) { //indent:10 exp:8 warn
System.getProperty("foo"); //indent:12 exp:12
System.getProperty("foo"); //indent:12 exp:12
} //indent:10 exp:8 warn
while (test) //indent:6 exp:8 warn
{ //indent:10 exp:8 warn
System.getProperty("foo"); //indent:12 exp:12
System.getProperty("foo"); //indent:12 exp:12
} //indent:6 exp:8 warn
while (test) { // : this is allowed //indent:8 exp:8
if (test) { //indent:14 exp:12 warn
System.getProperty("foo"); //indent:18 exp:16 warn
} //indent:14 exp:12 warn
System.getProperty("foo"); //indent:14 exp:12 warn
} //indent:10 exp:8 warn
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:10 exp:12 warn
&& 3 < 4) { //indent:12 exp:>=12
} //indent:8 exp:8
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:12 exp:>=12
&& 3 < 4) { //indent:10 exp:12 warn
} //indent:8 exp:8
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:12 exp:>=12
&& 3 < 4) //indent:10 exp:12 warn
{ //indent:8 exp:8
} //indent:8 exp:8
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:12 exp:>=12
&& 3 < 4 //indent:12 exp:>=12
) { //indent:5 exp:8 warn
} //indent:8 exp:8
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:12 exp:>=12
&& 3 < 4 //indent:12 exp:>=12
) { //indent:10 exp:8 warn
} //indent:8 exp:8
while (test //indent:8 exp:8
&& 4 < 7 && 8 < 9 //indent:12 exp:>=12
&& 3 < 4 //indent:12 exp:>=12
) //indent:10 exp:8 warn
{ //indent:8 exp:8
} //indent:8 exp:8
while (true) //indent:8 exp:8
{ //indent:8 exp:8
continue; //indent:8 exp:12 warn
} //indent:8 exp:8
} //indent:4 exp:4
} //indent:0 exp:0
| lgpl-2.1 |
danielru/moose | test/include/userobjects/PointerStoreError.h | 1489 | /****************************************************************/
/* DO NOT MODIFY THIS HEADER */
/* MOOSE - Multiphysics Object Oriented Simulation Environment */
/* */
/* (c) 2010 Battelle Energy Alliance, LLC */
/* ALL RIGHTS RESERVED */
/* */
/* Prepared by Battelle Energy Alliance, LLC */
/* Under Contract No. DE-AC07-05ID14517 */
/* With the U. S. Department of Energy */
/* */
/* See COPYRIGHT for full restrictions */
/****************************************************************/
#ifndef POINTERSTOREERROR_H
#define POINTERSTOREERROR_H
#include "GeneralUserObject.h"
class PointerStoreError;
template<>
InputParameters validParams<PointerStoreError>();
class ReallyDumb
{
public:
int _i;
};
class PointerStoreError : public GeneralUserObject
{
public:
PointerStoreError(const std::string & name, InputParameters params);
virtual ~PointerStoreError();
virtual void initialSetup();
virtual void timestepSetup();
virtual void initialize() {};
virtual void execute();
virtual void finalize() {};
protected:
ReallyDumb * & _pointer_data;
};
#endif /* POINTERSTOREERROR_H */
| lgpl-2.1 |
izzizz/pinot | pinot-transport/src/main/java/com/linkedin/pinot/routing/builder/RoutingTableInstancePruner.java | 2428 | /**
* Copyright (C) 2014-2015 LinkedIn Corp. ([email protected])
*
* 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.linkedin.pinot.routing.builder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.helix.model.InstanceConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.linkedin.pinot.common.utils.CommonConstants;
public class RoutingTableInstancePruner {
private static final Logger LOGGER = LoggerFactory.getLogger(RoutingTableInstancePruner.class);
private Map<String, InstanceConfig> instanceConfigMap;
public RoutingTableInstancePruner(List<InstanceConfig> instanceConfigList) {
instanceConfigMap = new HashMap<String, InstanceConfig>();
for (InstanceConfig config : instanceConfigList) {
instanceConfigMap.put(config.getInstanceName(), config);
}
}
public boolean isShuttingDown(String instanceName) {
if (!instanceConfigMap.containsKey(instanceName)) {
return false;
}
boolean status = false;
if (instanceConfigMap.get(instanceName).getRecord().getSimpleField(CommonConstants.Helix.IS_SHUTDOWN_IN_PROGRESS) != null) {
try {
if (instanceConfigMap.get(instanceName).getRecord() == null) {
return false;
}
if (instanceConfigMap.get(instanceName).getRecord()
.getSimpleField(CommonConstants.Helix.IS_SHUTDOWN_IN_PROGRESS) != null) {
status =
Boolean.valueOf(instanceConfigMap.get(instanceName).getRecord()
.getSimpleField(CommonConstants.Helix.IS_SHUTDOWN_IN_PROGRESS));
if (status == true) {
LOGGER.info("found an instance : {} in shutting down state", instanceName);
}
}
} catch (Exception e) {
LOGGER.error("unknown value found while parsing boolean isShuttingDownField ", e);
}
}
return status;
}
}
| apache-2.0 |
siosio/intellij-community | python/testData/inspections/PyDataclassInspection/defaultFieldValue.py | 1215 | import dataclasses
from typing import ClassVar, Dict, List, Set, Tuple, Type
from collections import OrderedDict
@dataclasses.dataclass
class A:
a: List[int] = <error descr="Mutable default '[]' is not allowed. Use 'default_factory'">[]</error>
b: List[int] = <error descr="Mutable default 'list()' is not allowed. Use 'default_factory'">list()</error>
c: Set[int] = <error descr="Mutable default '{1}' is not allowed. Use 'default_factory'">{1}</error>
d: Set[int] = <error descr="Mutable default 'set()' is not allowed. Use 'default_factory'">set()</error>
e: Tuple[int, ...] = ()
f: Tuple[int, ...] = tuple()
g: ClassVar[List[int]] = []
h: ClassVar = []
i: Dict[int, int] = <error descr="Mutable default '{1: 2}' is not allowed. Use 'default_factory'">{1: 2}</error>
j: Dict[int, int] = <error descr="Mutable default 'dict()' is not allowed. Use 'default_factory'">dict()</error>
k = []
l = list()
m: Dict[int, int] = <error descr="Mutable default 'OrderedDict()' is not allowed. Use 'default_factory'">OrderedDict()</error>
n: FrozenSet[int] = frozenset()
a2: Type[List[int]] = list
b2: Type[Set[int]] = set
c2: Type[Tuple[int, ...]] = tuple | apache-2.0 |
GlenRSmith/elasticsearch | x-pack/plugin/text-structure/src/test/java/org/elasticsearch/xpack/textstructure/structurefinder/GrokPatternCreatorTests.java | 37348 | /*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License
* 2.0; you may not use this file except in compliance with the Elastic License
* 2.0.
*/
package org.elasticsearch.xpack.textstructure.structurefinder;
import org.elasticsearch.core.Tuple;
import org.elasticsearch.xpack.textstructure.structurefinder.GrokPatternCreator.ValueOnlyGrokPatternCandidate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import static org.hamcrest.Matchers.containsInAnyOrder;
public class GrokPatternCreatorTests extends TextStructureTestCase {
public void testBuildFieldName() {
Map<String, Integer> fieldNameCountStore = new HashMap<>();
assertEquals("field", GrokPatternCreator.buildFieldName(fieldNameCountStore, "field"));
assertEquals("field2", GrokPatternCreator.buildFieldName(fieldNameCountStore, "field"));
assertEquals("field3", GrokPatternCreator.buildFieldName(fieldNameCountStore, "field"));
assertEquals("extra_timestamp", GrokPatternCreator.buildFieldName(fieldNameCountStore, "extra_timestamp"));
assertEquals("field4", GrokPatternCreator.buildFieldName(fieldNameCountStore, "field"));
assertEquals("uri", GrokPatternCreator.buildFieldName(fieldNameCountStore, "uri"));
assertEquals("extra_timestamp2", GrokPatternCreator.buildFieldName(fieldNameCountStore, "extra_timestamp"));
assertEquals("field5", GrokPatternCreator.buildFieldName(fieldNameCountStore, "field"));
}
public void testPopulatePrefacesAndEpiloguesGivenTimestamp() {
Collection<String> matchingStrings = Arrays.asList(
"[2018-01-25T15:33:23] DEBUG ",
"[2018-01-24T12:33:23] ERROR ",
"junk [2018-01-22T07:33:23] INFO ",
"[2018-01-21T03:33:23] DEBUG "
);
ValueOnlyGrokPatternCandidate candidate = new ValueOnlyGrokPatternCandidate("TIMESTAMP_ISO8601", "date", "extra_timestamp");
Map<String, Integer> fieldNameCountStore = new HashMap<>();
Collection<String> prefaces = new ArrayList<>();
Collection<String> epilogues = new ArrayList<>();
candidate.processCaptures(explanation, fieldNameCountStore, matchingStrings, prefaces, epilogues, null, null, NOOP_TIMEOUT_CHECKER);
assertThat(prefaces, containsInAnyOrder("[", "[", "junk [", "["));
assertThat(epilogues, containsInAnyOrder("] DEBUG ", "] ERROR ", "] INFO ", "] DEBUG "));
}
public void testPopulatePrefacesAndEpiloguesGivenEmailAddress() {
Collection<String> matchingStrings = Arrays.asList("before [email protected] after", "abc [email protected] xyz", "[email protected]");
ValueOnlyGrokPatternCandidate candidate = new ValueOnlyGrokPatternCandidate("EMAILADDRESS", "keyword", "email");
Map<String, Integer> fieldNameCountStore = new HashMap<>();
Collection<String> prefaces = new ArrayList<>();
Collection<String> epilogues = new ArrayList<>();
candidate.processCaptures(explanation, fieldNameCountStore, matchingStrings, prefaces, epilogues, null, null, NOOP_TIMEOUT_CHECKER);
assertThat(prefaces, containsInAnyOrder("before ", "abc ", ""));
assertThat(epilogues, containsInAnyOrder(" after", " xyz", ""));
}
public void testAppendBestGrokMatchForStringsGivenTimestampsAndLogLevels() {
Collection<String> snippets = Arrays.asList(
"[2018-01-25T15:33:23] DEBUG ",
"[2018-01-24T12:33:23] ERROR ",
"junk [2018-01-22T07:33:23] INFO ",
"[2018-01-21T03:33:23] DEBUG "
);
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(
".*?\\[%{TIMESTAMP_ISO8601:extra_timestamp}\\] %{LOGLEVEL:loglevel} ",
grokPatternCreator.getOverallGrokPatternBuilder().toString()
);
}
public void testAppendBestGrokMatchForStringsGivenNumbersInBrackets() {
Collection<String> snippets = Arrays.asList("(-2)", " (-3)", " (4)", " (-5) ");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*?\\(%{INT:field}\\).*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenNegativeNumbersWithoutBreak() {
Collection<String> snippets = Arrays.asList("before-2 ", "prior to-3", "-4");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
// It seems sensible that we don't detect these suffices as either base 10 or base 16 numbers
assertEquals(".*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenHexNumbers() {
Collection<String> snippets = Arrays.asList(" abc", " 123", " -123", "1f is hex");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*?%{BASE16NUM:field}.*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenHostnamesWithNumbers() {
Collection<String> snippets = Arrays.asList("<host1.1.p2ps:", "<host2.1.p2ps:");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
// We don't want the .1. in the middle to get detected as a hex number
assertEquals("<.*?:", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenEmailAddresses() {
Collection<String> snippets = Arrays.asList("before [email protected] after", "abc [email protected] xyz", "[email protected]");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*?%{EMAILADDRESS:email}.*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenUris() {
Collection<String> snippets = Arrays.asList(
"main site https://www.elastic.co/ with trailing slash",
"https://www.elastic.co/guide/en/x-pack/current/ml-configuring-categories.html#ml-configuring-categories is a section",
"download today from https://www.elastic.co/downloads"
);
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*?%{URI:uri}.*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenPaths() {
Collection<String> snippets = Arrays.asList("on Mac /Users/dave", "on Windows C:\\Users\\dave", "on Linux /home/dave");
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*? .*? %{PATH:path}", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testAppendBestGrokMatchForStringsGivenKvPairs() {
Collection<String> snippets = Arrays.asList(
"foo=1 and bar=a",
"something foo=2 bar=b something else",
"foo=3 bar=c",
" foo=1 bar=a "
);
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.appendBestGrokMatchForStrings(false, snippets, false, 0);
assertEquals(".*?\\bfoo=%{USER:foo} .*?\\bbar=%{USER:bar}.*?", grokPatternCreator.getOverallGrokPatternBuilder().toString());
}
public void testCreateGrokPatternFromExamplesGivenNamedLogs() {
Collection<String> sampleMessages = Arrays.asList(
"Sep 8 11:55:06 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'elastic.slack.com/A/IN': 95.110.64.205#53",
"Sep 8 11:55:08 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'slack-imgs.com/A/IN': 95.110.64.205#53",
"Sep 8 11:55:35 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'www.elastic.co/A/IN': 95.110.68.206#53",
"Sep 8 11:55:42 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'b.akamaiedge.net/A/IN': 95.110.64.205#53"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
"%{SYSLOGTIMESTAMP:timestamp} .*? .*?\\[%{INT:field}\\]: %{LOGLEVEL:loglevel} \\(.*? .*? .*?\\) .*? "
+ "%{QUOTEDSTRING:field2}: %{IP:ipaddress}#%{INT:field3}",
grokPatternCreator.createGrokPatternFromExamples("SYSLOGTIMESTAMP", TextStructureUtils.DATE_MAPPING_WITHOUT_FORMAT, "timestamp")
);
assertEquals(5, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("field2"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("ipaddress"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field3"));
}
public void testCreateGrokPatternFromExamplesGivenCatalinaLogs() {
Collection<String> sampleMessages = Arrays.asList(
"Aug 29, 2009 12:03:33 AM org.apache.tomcat.util.http.Parameters processParameters\nWARNING: Parameters: "
+ "Invalid chunk ignored.",
"Aug 29, 2009 12:03:40 AM org.apache.tomcat.util.http.Parameters processParameters\nWARNING: Parameters: "
+ "Invalid chunk ignored.",
"Aug 29, 2009 12:03:45 AM org.apache.tomcat.util.http.Parameters processParameters\nWARNING: Parameters: "
+ "Invalid chunk ignored.",
"Aug 29, 2009 12:03:57 AM org.apache.tomcat.util.http.Parameters processParameters\nWARNING: Parameters: "
+ "Invalid chunk ignored."
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
"%{CATALINA_DATESTAMP:timestamp} .*? .*?\\n%{LOGLEVEL:loglevel}: .*",
grokPatternCreator.createGrokPatternFromExamples(
"CATALINA_DATESTAMP",
TextStructureUtils.DATE_MAPPING_WITHOUT_FORMAT,
"timestamp"
)
);
assertEquals(1, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
}
public void testCreateGrokPatternFromExamplesGivenMultiTimestampLogs() {
// Two timestamps: one local, one UTC
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
"%{INT:field}\\t%{TIMESTAMP_ISO8601:timestamp}\\t%{TIMESTAMP_ISO8601:extra_timestamp}\\t%{INT:field2}\\t.*?\\t"
+ "%{IP:ipaddress}\\t.*?\\t%{LOGLEVEL:loglevel}\\t.*",
grokPatternCreator.createGrokPatternFromExamples(
"TIMESTAMP_ISO8601",
TextStructureUtils.DATE_MAPPING_WITHOUT_FORMAT,
"timestamp"
)
);
assertEquals(5, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field"));
Map<String, String> expectedDateMapping = new HashMap<>();
expectedDateMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date");
expectedDateMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "iso8601");
assertEquals(expectedDateMapping, mappings.get("extra_timestamp"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field2"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("ipaddress"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
}
public void testCreateGrokPatternFromExamplesGivenMultiTimestampLogsAndIndeterminateFormat() {
// Two timestamps: one ISO8601, one indeterminate day/month
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t2016-04-20T14:06:53\t20/04/2016 21:06:53,123456\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t2016-04-20T14:06:53\t20/04/2016 21:06:53,123456\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t2016-04-20T14:06:53\t20/04/2016 21:06:53,123456\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t2016-04-20T14:06:53\t20/04/2016 21:06:53,123456\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
"%{INT:field}\\t%{TIMESTAMP_ISO8601:timestamp}\\t%{DATESTAMP:extra_timestamp}\\t%{INT:field2}\\t.*?\\t"
+ "%{IP:ipaddress}\\t.*?\\t%{LOGLEVEL:loglevel}\\t.*",
grokPatternCreator.createGrokPatternFromExamples(
"TIMESTAMP_ISO8601",
TextStructureUtils.DATE_MAPPING_WITHOUT_FORMAT,
"timestamp"
)
);
assertEquals(5, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field"));
Map<String, String> expectedDateMapping = new HashMap<>();
expectedDateMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date_nanos");
expectedDateMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "dd/MM/yyyy HH:mm:ss,SSSSSS");
assertEquals(expectedDateMapping, mappings.get("extra_timestamp"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field2"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("ipaddress"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
}
public void testCreateGrokPatternFromExamplesGivenMultiTimestampLogsAndCustomDefinition() {
// Two timestamps: one custom, one built-in
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.singletonMap("CUSTOM_TIMESTAMP", "%{MONTHNUM}/%{MONTHDAY}/%{YEAR} %{HOUR}:%{MINUTE}(?:AM|PM)"),
NOOP_TIMEOUT_CHECKER
);
Map<String, String> customMapping = new HashMap<>();
customMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date");
customMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "M/dd/yyyy h:mma");
assertEquals(
"%{INT:field}\\t%{CUSTOM_TIMESTAMP:timestamp}\\t%{TIMESTAMP_ISO8601:extra_timestamp}\\t%{INT:field2}\\t.*?\\t"
+ "%{IP:ipaddress}\\t.*?\\t%{LOGLEVEL:loglevel}\\t.*",
grokPatternCreator.createGrokPatternFromExamples("CUSTOM_TIMESTAMP", customMapping, "timestamp")
);
assertEquals(5, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field"));
Map<String, String> expectedDateMapping = new HashMap<>();
expectedDateMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date");
expectedDateMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "iso8601");
assertEquals(expectedDateMapping, mappings.get("extra_timestamp"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field2"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("ipaddress"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
}
public void testCreateGrokPatternFromExamplesGivenTimestampAndTimeWithoutDate() {
// Two timestamps: one with date, one without
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t2016-04-20T14:06:53\t21:06:53.123456\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t2016-04-20T14:06:53\t21:06:53.123456\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t2016-04-20T14:06:53\t21:06:53.123456\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t2016-04-20T14:06:53\t21:06:53.123456\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
"%{INT:field}\\t%{TIMESTAMP_ISO8601:timestamp}\\t%{TIME:time}\\t%{INT:field2}\\t.*?\\t"
+ "%{IP:ipaddress}\\t.*?\\t%{LOGLEVEL:loglevel}\\t.*",
grokPatternCreator.createGrokPatternFromExamples(
"TIMESTAMP_ISO8601",
TextStructureUtils.DATE_MAPPING_WITHOUT_FORMAT,
"timestamp"
)
);
assertEquals(5, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("time"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("field2"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("ipaddress"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("loglevel"));
}
public void testFindFullLineGrokPatternGivenApacheCombinedLogs() {
Collection<String> sampleMessages = Arrays.asList(
"83.149.9.216 - - [19/Jan/2016:08:13:42 +0000] "
+ "\"GET /presentations/logstash-monitorama-2013/images/kibana-search.png HTTP/1.1\" 200 203023 "
+ "\"http://semicomplete.com/presentations/logstash-monitorama-2013/\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.77 Safari/537.36\"",
"83.149.9.216 - - [19/Jan/2016:08:13:44 +0000] "
+ "\"GET /presentations/logstash-monitorama-2013/plugin/zoom-js/zoom.js HTTP/1.1\" 200 7697 "
+ "\"http://semicomplete.com/presentations/logstash-monitorama-2013/\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.77 Safari/537.36\"",
"83.149.9.216 - - [19/Jan/2016:08:13:44 +0000] "
+ "\"GET /presentations/logstash-monitorama-2013/plugin/highlight/highlight.js HTTP/1.1\" 200 26185 "
+ "\"http://semicomplete.com/presentations/logstash-monitorama-2013/\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.77 Safari/537.36\"",
"83.149.9.216 - - [19/Jan/2016:08:13:42 +0000] "
+ "\"GET /presentations/logstash-monitorama-2013/images/sad-medic.png HTTP/1.1\" 200 430406 "
+ "\"http://semicomplete.com/presentations/logstash-monitorama-2013/\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.77 Safari/537.36\""
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
assertEquals(
new Tuple<>("timestamp", "%{COMBINEDAPACHELOG}"),
grokPatternCreator.findFullLineGrokPattern(randomBoolean() ? "timestamp" : null)
);
assertEquals(10, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "text"), mappings.get("agent"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("auth"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("bytes"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("clientip"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "double"), mappings.get("httpversion"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("ident"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("referrer"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("request"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("response"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("verb"));
}
public void testAdjustForPunctuationGivenCommonPrefix() {
Collection<String> snippets = """
","lab6.localhost","Route Domain","/Common/0","No-lookup","192.168.33.212","No-lookup","192.168.33.132","80","46721",\
"/Common/Subnet_33","TCP","0","","","","","","","","Staged","/Common/policy1","rule1","Accept","","","",\
"0000000000000000"
","lab6.localhost","Route Domain","/Common/0","No-lookup","192.168.143.244","No-lookup","192.168.33.106","55025","162",\
"/Common/Subnet_33","UDP","0","","","","","","","","Staged","/Common/policy1","rule1","Accept","","","",\
"0000000000000000"
","lab6.localhost","Route Domain","/Common/0","No-lookup","192.168.33.3","No-lookup","224.0.0.102","3222","3222",\
"/Common/Subnet_33","UDP","0","","","","","","","","Staged","/Common/policy1","rule1","Accept","","","",\
"0000000000000000"\
""".lines().toList();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
Collection<String> adjustedSnippets = grokPatternCreator.adjustForPunctuation(snippets);
assertEquals("\",", grokPatternCreator.getOverallGrokPatternBuilder().toString());
assertNotNull(adjustedSnippets);
assertThat(
new ArrayList<>(adjustedSnippets),
containsInAnyOrder(snippets.stream().map(snippet -> snippet.substring(2)).toArray(String[]::new))
);
}
public void testAdjustForPunctuationGivenNoCommonPrefix() {
Collection<String> snippets = Arrays.asList(
"|client (id:2) was removed from servergroup 'Normal'(id:7) by client 'User1'(id:2)",
"|servergroup 'GAME'(id:9) was added by 'User1'(id:2)",
"|permission 'i_group_auto_update_type'(id:146) with values (value:30, negated:0, skipchannel:0) "
+ "was added by 'User1'(id:2) to servergroup 'GAME'(id:9)"
);
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
snippets,
null,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
Collection<String> adjustedSnippets = grokPatternCreator.adjustForPunctuation(snippets);
assertEquals("", grokPatternCreator.getOverallGrokPatternBuilder().toString());
assertSame(snippets, adjustedSnippets);
}
public void testValidateFullLineGrokPatternGivenValid() {
String timestampField = "utc_timestamp";
String grokPattern = "%{INT:serial_no}\\t%{TIMESTAMP_ISO8601:local_timestamp}\\t%{TIMESTAMP_ISO8601:utc_timestamp}\\t"
+ "%{INT:user_id}\\t%{HOSTNAME:host}\\t%{IP:client_ip}\\t%{WORD:method}\\t%{LOGLEVEL:severity}\\t%{PROG:program}\\t"
+ "%{GREEDYDATA:message}";
// Two timestamps: one local, one UTC
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t2016-04-20T14:06:53\t2016-04-20T21:06:53Z\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.validateFullLineGrokPattern(grokPattern, timestampField);
assertEquals(9, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("serial_no"));
Map<String, String> expectedDateMapping = new HashMap<>();
expectedDateMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date");
expectedDateMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "iso8601");
assertEquals(expectedDateMapping, mappings.get("local_timestamp"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("user_id"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("host"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("client_ip"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("method"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("severity"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("program"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("message"));
}
public void testValidateFullLineGrokPatternGivenValidAndCustomDefinition() {
String timestampField = "local_timestamp";
String grokPattern = "%{INT:serial_no}\\t%{CUSTOM_TIMESTAMP:local_timestamp}\\t%{TIMESTAMP_ISO8601:utc_timestamp}\\t"
+ "%{INT:user_id}\\t%{HOSTNAME:host}\\t%{IP:client_ip}\\t%{WORD:method}\\t%{LOGLEVEL:severity}\\t%{PROG:program}\\t"
+ "%{GREEDYDATA:message}";
// Two timestamps: one local, one UTC
Collection<String> sampleMessages = Arrays.asList(
"559550912540598297\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t38545844\tserv02nw07\t192.168.114.28\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986880\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t9049724\tserv02nw03\t10.120.48.147\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912548986887\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t884343\tserv02tw03\t192.168.121.189\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp",
"559550912603512850\t4/20/2016 2:06PM\t2016-04-20T21:06:53Z\t8907014\tserv02nw01\t192.168.118.208\tAuthpriv\t"
+ "Info\tsshd\tsubsystem request for sftp"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.singletonMap("CUSTOM_TIMESTAMP", "%{MONTHNUM}/%{MONTHDAY}/%{YEAR} %{HOUR}:%{MINUTE}(?:AM|PM)"),
NOOP_TIMEOUT_CHECKER
);
grokPatternCreator.validateFullLineGrokPattern(grokPattern, timestampField);
assertEquals(9, mappings.size());
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("serial_no"));
Map<String, String> expectedDateMapping = new HashMap<>();
expectedDateMapping.put(TextStructureUtils.MAPPING_TYPE_SETTING, "date");
expectedDateMapping.put(TextStructureUtils.MAPPING_FORMAT_SETTING, "iso8601");
assertEquals(expectedDateMapping, mappings.get("utc_timestamp"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "long"), mappings.get("user_id"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("host"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "ip"), mappings.get("client_ip"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("method"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("severity"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("program"));
assertEquals(Collections.singletonMap(TextStructureUtils.MAPPING_TYPE_SETTING, "keyword"), mappings.get("message"));
}
public void testValidateFullLineGrokPatternGivenInvalid() {
String timestampField = "utc_timestamp";
String grokPattern = "%{INT:serial_no}\\t%{TIMESTAMP_ISO8601:local_timestamp}\\t%{TIMESTAMP_ISO8601:utc_timestamp}\\t"
+ "%{INT:user_id}\\t%{HOSTNAME:host}\\t%{IP:client_ip}\\t%{WORD:method}\\t%{LOGLEVEL:severity}\\t%{PROG:program}\\t"
+ "%{GREEDYDATA:message}";
Collection<String> sampleMessages = Arrays.asList(
"Sep 8 11:55:06 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'elastic.slack.com/A/IN': 95.110.64.205#53",
"Sep 8 11:55:08 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'slack-imgs.com/A/IN': 95.110.64.205#53",
"Sep 8 11:55:35 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'www.elastic.co/A/IN': 95.110.68.206#53",
"Sep 8 11:55:42 linux named[22529]: error (unexpected RCODE REFUSED) resolving 'b.akamaiedge.net/A/IN': 95.110.64.205#53"
);
Map<String, Object> mappings = new HashMap<>();
GrokPatternCreator grokPatternCreator = new GrokPatternCreator(
explanation,
sampleMessages,
mappings,
null,
Collections.emptyMap(),
NOOP_TIMEOUT_CHECKER
);
IllegalArgumentException e = expectThrows(
IllegalArgumentException.class,
() -> grokPatternCreator.validateFullLineGrokPattern(grokPattern, timestampField)
);
assertEquals("Supplied Grok pattern [" + grokPattern + "] does not match sample messages", e.getMessage());
}
}
| apache-2.0 |
Subsets and Splits