diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 77a58e9..b3a7f07 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -29,6 +29,10 @@ { "ImportPath": "github.com/tarm/goserial", "Rev": "cdabc8d44e8e84f58f18074ae44337e1f2f375b9" + }, + { + "ImportPath": "github.com/sigma/vmw-guestinfo", + "Rev": "de573afc542e0268fe8478d46e237fad9d6f7aec" } ] } diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/COPYING b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/COPYING new file mode 100644 index 0000000..09f465a --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/COPYING @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This 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 2.1 of the License, or (at your option) any later version. + + This 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 this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor.c new file mode 100644 index 0000000..2e10fde --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor.c @@ -0,0 +1,272 @@ +/********************************************************* + * Copyright (C) 1999-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoor.c -- + * + * First layer of the internal communication channel between guest + * applications and vmware + * + * This is the backdoor. By using special ports of the virtual I/O space, + * and the virtual CPU registers, a guest application can send a + * synchroneous basic request to vmware, and vmware can reply to it. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "backdoor_def.h" +#include "backdoor.h" +#include "backdoorInt.h" + +#if defined(BACKDOOR_DEBUG) && defined(USERLEVEL) +#if defined(__KERNEL__) || defined(_KERNEL) +#else +# include "debug.h" +#endif +# include +# define BACKDOOR_LOG(args) Debug args +# define BACKDOOR_LOG_PROTO_STRUCT(x) BackdoorPrintProtoStruct((x)) +# define BACKDOOR_LOG_HB_PROTO_STRUCT(x) BackdoorPrintHbProtoStruct((x)) + + +/* + *---------------------------------------------------------------------------- + * + * BackdoorPrintProtoStruct -- + * BackdoorPrintHbProtoStruct -- + * + * Print the contents of the specified backdoor protocol structure via + * printf. + * + * Results: + * None. + * + * Side effects: + * Output to stdout. + * + *---------------------------------------------------------------------------- + */ + +void +BackdoorPrintProtoStruct(Backdoor_proto *myBp) +{ + Debug("magic 0x%08x, command %d, size %"FMTSZ"u, port %d\n", + myBp->in.ax.word, myBp->in.cx.halfs.low, + myBp->in.size, myBp->in.dx.halfs.low); + +#ifndef VM_X86_64 + Debug("ax %#x, " + "bx %#x, " + "cx %#x, " + "dx %#x, " + "si %#x, " + "di %#x\n", + myBp->out.ax.word, + myBp->out.bx.word, + myBp->out.cx.word, + myBp->out.dx.word, + myBp->out.si.word, + myBp->out.di.word); +#else + Debug("ax %#"FMT64"x, " + "bx %#"FMT64"x, " + "cx %#"FMT64"x, " + "dx %#"FMT64"x, " + "si %#"FMT64"x, " + "di %#"FMT64"x\n", + myBp->out.ax.quad, + myBp->out.bx.quad, + myBp->out.cx.quad, + myBp->out.dx.quad, + myBp->out.si.quad, + myBp->out.di.quad); +#endif +} + + +void +BackdoorPrintHbProtoStruct(Backdoor_proto_hb *myBp) +{ + Debug("magic 0x%08x, command %d, size %"FMTSZ"u, port %d, " + "srcAddr %"FMTSZ"u, dstAddr %"FMTSZ"u\n", + myBp->in.ax.word, myBp->in.bx.halfs.low, myBp->in.size, + myBp->in.dx.halfs.low, myBp->in.srcAddr, myBp->in.dstAddr); + +#ifndef VM_X86_64 + Debug("ax %#x, " + "bx %#x, " + "cx %#x, " + "dx %#x, " + "si %#x, " + "di %#x, " + "bp %#x\n", + myBp->out.ax.word, + myBp->out.bx.word, + myBp->out.cx.word, + myBp->out.dx.word, + myBp->out.si.word, + myBp->out.di.word, + myBp->out.bp.word); +#else + Debug("ax %#"FMT64"x, " + "bx %#"FMT64"x, " + "cx %#"FMT64"x, " + "dx %#"FMT64"x, " + "si %#"FMT64"x, " + "di %#"FMT64"x, " + "bp %#"FMT64"x\n", + myBp->out.ax.quad, + myBp->out.bx.quad, + myBp->out.cx.quad, + myBp->out.dx.quad, + myBp->out.si.quad, + myBp->out.di.quad, + myBp->out.bp.quad); +#endif +} + +#else +# define BACKDOOR_LOG(args) +# define BACKDOOR_LOG_PROTO_STRUCT(x) +# define BACKDOOR_LOG_HB_PROTO_STRUCT(x) +#endif + + +/* + *----------------------------------------------------------------------------- + * + * Backdoor -- + * + * Send a low-bandwidth basic request (16 bytes) to vmware, and return its + * reply (24 bytes). + * + * Result: + * None + * + * Side-effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void +Backdoor(Backdoor_proto *myBp) // IN/OUT +{ + ASSERT(myBp); + + myBp->in.ax.word = BDOOR_MAGIC; + myBp->in.dx.halfs.low = BDOOR_PORT; + + BACKDOOR_LOG(("Backdoor: before ")); + BACKDOOR_LOG_PROTO_STRUCT(myBp); + + Backdoor_InOut(myBp); + + BACKDOOR_LOG(("Backdoor: after ")); + BACKDOOR_LOG_PROTO_STRUCT(myBp); +} + + +/* + *----------------------------------------------------------------------------- + * + * Backdoor_HbOut -- + * + * Send a high-bandwidth basic request to vmware, and return its + * reply. + * + * Result: + * The host-side response is returned via the IN/OUT parameter. + * + * Side-effects: + * Pokes the high-bandwidth backdoor. + * + *----------------------------------------------------------------------------- + */ + +void +Backdoor_HbOut(Backdoor_proto_hb *myBp) // IN/OUT +{ + ASSERT(myBp); + + myBp->in.ax.word = BDOOR_MAGIC; + myBp->in.dx.halfs.low = BDOORHB_PORT; + + BACKDOOR_LOG(("Backdoor_HbOut: before ")); + BACKDOOR_LOG_HB_PROTO_STRUCT(myBp); + + BackdoorHbOut(myBp); + + BACKDOOR_LOG(("Backdoor_HbOut: after ")); + BACKDOOR_LOG_HB_PROTO_STRUCT(myBp); +} + + +/* + *----------------------------------------------------------------------------- + * + * Backdoor_HbIn -- + * + * Send a basic request to vmware, and return its high-bandwidth + * reply + * + * Result: + * Host-side response returned via the IN/OUT parameter. + * + * Side-effects: + * Pokes the high-bandwidth backdoor. + * + *----------------------------------------------------------------------------- + */ + +void +Backdoor_HbIn(Backdoor_proto_hb *myBp) // IN/OUT +{ + ASSERT(myBp); + + myBp->in.ax.word = BDOOR_MAGIC; + myBp->in.dx.halfs.low = BDOORHB_PORT; + + BACKDOOR_LOG(("Backdoor_HbIn: before ")); + BACKDOOR_LOG_HB_PROTO_STRUCT(myBp); + + BackdoorHbIn(myBp); + + BACKDOOR_LOG(("Backdoor_HbIn: after ")); + BACKDOOR_LOG_HB_PROTO_STRUCT(myBp); +} + +#ifdef __cplusplus +} +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_386.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_386.c new file mode 100644 index 0000000..d402cb0 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_386.c @@ -0,0 +1,235 @@ +/********************************************************* + * Copyright (C) 2005-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoorGcc32.c -- + * + * Implements the real work for guest-side backdoor for GCC, 32-bit + * target (supports inline ASM, GAS syntax). The asm sections are marked + * volatile since vmware can change the registers content without the + * compiler knowing it. + * + * XXX + * I tried to write this more cleanly, but: + * - There is no way to specify an "ebp" constraint + * - "ebp" is ignored when specified as cloberred register + * - gas barfs when there is more than 10 operands + * - gas 2.7.2.3, depending on the order of the operands, can + * mis-assemble without any warning + * --hpreg + * + * Note that the problems with gas noted above might longer be relevant + * now that we've upgraded most of our compiler versions. + * --rrdharan + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "backdoor.h" +#include "backdoorInt.h" + +/* + *---------------------------------------------------------------------------- + * + * Backdoor_InOut -- + * + * Send a low-bandwidth basic request (16 bytes) to vmware, and return its + * reply (24 bytes). + * + * Results: + * Host-side response returned in bp IN/OUT parameter. + * + * Side effects: + * Pokes the backdoor. + * + *---------------------------------------------------------------------------- + */ + +void +Backdoor_InOut(Backdoor_proto *myBp) // IN/OUT +{ + uint32 dummy; + + __asm__ __volatile__( +#ifdef __PIC__ + "pushl %%ebx" "\n\t" +#endif + "pushl %%eax" "\n\t" + "movl 20(%%eax), %%edi" "\n\t" + "movl 16(%%eax), %%esi" "\n\t" + "movl 12(%%eax), %%edx" "\n\t" + "movl 8(%%eax), %%ecx" "\n\t" + "movl 4(%%eax), %%ebx" "\n\t" + "movl (%%eax), %%eax" "\n\t" + "inl %%dx, %%eax" "\n\t" + "xchgl %%eax, (%%esp)" "\n\t" + "movl %%edi, 20(%%eax)" "\n\t" + "movl %%esi, 16(%%eax)" "\n\t" + "movl %%edx, 12(%%eax)" "\n\t" + "movl %%ecx, 8(%%eax)" "\n\t" + "movl %%ebx, 4(%%eax)" "\n\t" + "popl (%%eax)" "\n\t" +#ifdef __PIC__ + "popl %%ebx" "\n\t" +#endif + : "=a" (dummy) + : "0" (myBp) + /* + * vmware can modify the whole VM state without the compiler knowing + * it. So far it does not modify EFLAGS. --hpreg + */ + : +#ifndef __PIC__ + "ebx", +#endif + "ecx", "edx", "esi", "edi", "memory" + ); +} + + +/* + *----------------------------------------------------------------------------- + * + * BackdoorHbIn -- + * BackdoorHbOut -- + * + * Send a high-bandwidth basic request to vmware, and return its + * reply. + * + * Results: + * Host-side response returned in bp IN/OUT parameter. + * + * Side-effects: + * Pokes the high-bandwidth backdoor port. + * + *----------------------------------------------------------------------------- + */ + +void +BackdoorHbIn(Backdoor_proto_hb *myBp) // IN/OUT +{ + uint32 dummy; + + __asm__ __volatile__( +#ifdef __PIC__ + "pushl %%ebx" "\n\t" +#endif + "pushl %%ebp" "\n\t" + + "pushl %%eax" "\n\t" + "movl 24(%%eax), %%ebp" "\n\t" + "movl 20(%%eax), %%edi" "\n\t" + "movl 16(%%eax), %%esi" "\n\t" + "movl 12(%%eax), %%edx" "\n\t" + "movl 8(%%eax), %%ecx" "\n\t" + "movl 4(%%eax), %%ebx" "\n\t" + "movl (%%eax), %%eax" "\n\t" + "cld" "\n\t" + "rep; insb" "\n\t" + "xchgl %%eax, (%%esp)" "\n\t" + "movl %%ebp, 24(%%eax)" "\n\t" + "movl %%edi, 20(%%eax)" "\n\t" + "movl %%esi, 16(%%eax)" "\n\t" + "movl %%edx, 12(%%eax)" "\n\t" + "movl %%ecx, 8(%%eax)" "\n\t" + "movl %%ebx, 4(%%eax)" "\n\t" + "popl (%%eax)" "\n\t" + + "popl %%ebp" "\n\t" +#ifdef __PIC__ + "popl %%ebx" "\n\t" +#endif + : "=a" (dummy) + : "0" (myBp) + /* + * vmware can modify the whole VM state without the compiler knowing + * it. --hpreg + */ + : +#ifndef __PIC__ + "ebx", +#endif + "ecx", "edx", "esi", "edi", "memory", "cc" + ); +} + + +void +BackdoorHbOut(Backdoor_proto_hb *myBp) // IN/OUT +{ + uint32 dummy; + + __asm__ __volatile__( +#ifdef __PIC__ + "pushl %%ebx" "\n\t" +#endif + "pushl %%ebp" "\n\t" + + "pushl %%eax" "\n\t" + "movl 24(%%eax), %%ebp" "\n\t" + "movl 20(%%eax), %%edi" "\n\t" + "movl 16(%%eax), %%esi" "\n\t" + "movl 12(%%eax), %%edx" "\n\t" + "movl 8(%%eax), %%ecx" "\n\t" + "movl 4(%%eax), %%ebx" "\n\t" + "movl (%%eax), %%eax" "\n\t" + "cld" "\n\t" + "rep; outsb" "\n\t" + "xchgl %%eax, (%%esp)" "\n\t" + "movl %%ebp, 24(%%eax)" "\n\t" + "movl %%edi, 20(%%eax)" "\n\t" + "movl %%esi, 16(%%eax)" "\n\t" + "movl %%edx, 12(%%eax)" "\n\t" + "movl %%ecx, 8(%%eax)" "\n\t" + "movl %%ebx, 4(%%eax)" "\n\t" + "popl (%%eax)" "\n\t" + + "popl %%ebp" "\n\t" +#ifdef __PIC__ + "popl %%ebx" "\n\t" +#endif + : "=a" (dummy) + : "0" (myBp) + : +#ifndef __PIC__ + "ebx", +#endif + "ecx", "edx", "esi", "edi", "memory", "cc" + ); +} + +#ifdef __cplusplus +} +#endif + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_amd64.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_amd64.c new file mode 100644 index 0000000..551b7cd --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/backdoor_amd64.c @@ -0,0 +1,243 @@ +/********************************************************* + * Copyright (C) 2005-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoorGcc64.c -- + * + * Implements the real work for guest-side backdoor for GCC, 64-bit + * target (supports inline ASM, GAS syntax). The asm sections are marked + * volatile since vmware can change the registers content without the + * compiler knowing it. + * + * See backdoorGCC32.c (from which this code was mostly copied) for + * details on why the ASM is written this way. Also note that it might be + * possible to write the asm blocks using the symbolic operand specifiers + * in such a way that the same asm would generate correct code for both + * 32-bit and 64-bit targets, but I'm too lazy to figure it all out. + * --rrdharan + */ +#ifdef __cplusplus +extern "C" { +#endif + +#include "backdoor.h" +#include "backdoorInt.h" + + +/* + *---------------------------------------------------------------------------- + * + * Backdoor_InOut -- + * + * Send a low-bandwidth basic request (16 bytes) to vmware, and return its + * reply (24 bytes). + * + * Results: + * Host-side response returned in bp IN/OUT parameter. + * + * Side effects: + * Pokes the backdoor. + * + *---------------------------------------------------------------------------- + */ + +void +Backdoor_InOut(Backdoor_proto *myBp) // IN/OUT +{ + uint64 dummy; + + __asm__ __volatile__( +#ifdef __APPLE__ + /* + * Save %rbx on the stack because the Mac OS GCC doesn't want us to + * clobber it - it erroneously thinks %rbx is the PIC register. + * (Radar bug 7304232) + */ + "pushq %%rbx" "\n\t" +#endif + "pushq %%rax" "\n\t" + "movq 40(%%rax), %%rdi" "\n\t" + "movq 32(%%rax), %%rsi" "\n\t" + "movq 24(%%rax), %%rdx" "\n\t" + "movq 16(%%rax), %%rcx" "\n\t" + "movq 8(%%rax), %%rbx" "\n\t" + "movq (%%rax), %%rax" "\n\t" + "inl %%dx, %%eax" "\n\t" /* NB: There is no inq instruction */ + "xchgq %%rax, (%%rsp)" "\n\t" + "movq %%rdi, 40(%%rax)" "\n\t" + "movq %%rsi, 32(%%rax)" "\n\t" + "movq %%rdx, 24(%%rax)" "\n\t" + "movq %%rcx, 16(%%rax)" "\n\t" + "movq %%rbx, 8(%%rax)" "\n\t" + "popq (%%rax)" "\n\t" +#ifdef __APPLE__ + "popq %%rbx" "\n\t" +#endif + : "=a" (dummy) + : "0" (myBp) + /* + * vmware can modify the whole VM state without the compiler knowing + * it. So far it does not modify EFLAGS. --hpreg + */ + : +#ifndef __APPLE__ + /* %rbx is unchanged at the end of the function on Mac OS. */ + "rbx", +#endif + "rcx", "rdx", "rsi", "rdi", "memory" + ); +} + + +/* + *----------------------------------------------------------------------------- + * + * BackdoorHbIn -- + * BackdoorHbOut -- + * + * Send a high-bandwidth basic request to vmware, and return its + * reply. + * + * Results: + * Host-side response returned in bp IN/OUT parameter. + * + * Side-effects: + * Pokes the high-bandwidth backdoor port. + * + *----------------------------------------------------------------------------- + */ + +void +BackdoorHbIn(Backdoor_proto_hb *myBp) // IN/OUT +{ + uint64 dummy; + + __asm__ __volatile__( + "pushq %%rbp" "\n\t" +#ifdef __APPLE__ + /* + * Save %rbx on the stack because the Mac OS GCC doesn't want us to + * clobber it - it erroneously thinks %rbx is the PIC register. + * (Radar bug 7304232) + */ + "pushq %%rbx" "\n\t" +#endif + "pushq %%rax" "\n\t" + "movq 48(%%rax), %%rbp" "\n\t" + "movq 40(%%rax), %%rdi" "\n\t" + "movq 32(%%rax), %%rsi" "\n\t" + "movq 24(%%rax), %%rdx" "\n\t" + "movq 16(%%rax), %%rcx" "\n\t" + "movq 8(%%rax), %%rbx" "\n\t" + "movq (%%rax), %%rax" "\n\t" + "cld" "\n\t" + "rep; insb" "\n\t" + "xchgq %%rax, (%%rsp)" "\n\t" + "movq %%rbp, 48(%%rax)" "\n\t" + "movq %%rdi, 40(%%rax)" "\n\t" + "movq %%rsi, 32(%%rax)" "\n\t" + "movq %%rdx, 24(%%rax)" "\n\t" + "movq %%rcx, 16(%%rax)" "\n\t" + "movq %%rbx, 8(%%rax)" "\n\t" + "popq (%%rax)" "\n\t" +#ifdef __APPLE__ + "popq %%rbx" "\n\t" +#endif + "popq %%rbp" + : "=a" (dummy) + : "0" (myBp) + /* + * vmware can modify the whole VM state without the compiler knowing + * it. --hpreg + */ + : +#ifndef __APPLE__ + /* %rbx is unchanged at the end of the function on Mac OS. */ + "rbx", +#endif + "rcx", "rdx", "rsi", "rdi", "memory", "cc" + ); +} + + +void +BackdoorHbOut(Backdoor_proto_hb *myBp) // IN/OUT +{ + uint64 dummy; + + __asm__ __volatile__( + "pushq %%rbp" "\n\t" +#ifdef __APPLE__ + /* + * Save %rbx on the stack because the Mac OS GCC doesn't want us to + * clobber it - it erroneously thinks %rbx is the PIC register. + * (Radar bug 7304232) + */ + "pushq %%rbx" "\n\t" +#endif + "pushq %%rax" "\n\t" + "movq 48(%%rax), %%rbp" "\n\t" + "movq 40(%%rax), %%rdi" "\n\t" + "movq 32(%%rax), %%rsi" "\n\t" + "movq 24(%%rax), %%rdx" "\n\t" + "movq 16(%%rax), %%rcx" "\n\t" + "movq 8(%%rax), %%rbx" "\n\t" + "movq (%%rax), %%rax" "\n\t" + "cld" "\n\t" + "rep; outsb" "\n\t" + "xchgq %%rax, (%%rsp)" "\n\t" + "movq %%rbp, 48(%%rax)" "\n\t" + "movq %%rdi, 40(%%rax)" "\n\t" + "movq %%rsi, 32(%%rax)" "\n\t" + "movq %%rdx, 24(%%rax)" "\n\t" + "movq %%rcx, 16(%%rax)" "\n\t" + "movq %%rbx, 8(%%rax)" "\n\t" + "popq (%%rax)" "\n\t" +#ifdef __APPLE__ + "popq %%rbx" "\n\t" +#endif + "popq %%rbp" + : "=a" (dummy) + : "0" (myBp) + : +#ifndef __APPLE__ + /* %rbx is unchanged at the end of the function on Mac OS. */ + "rbx", +#endif + "rcx", "rdx", "rsi", "rdi", "memory", "cc" + ); +} + + +#ifdef __cplusplus +} +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/bridge.go b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/bridge.go new file mode 100644 index 0000000..4302121 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/bridge.go @@ -0,0 +1,60 @@ +package bridge + +/* +#cgo CFLAGS: -I../include +#include +#include "message.h" +#include "vmcheck.h" +void Warning(const char *fmt, ...) {} +void Debug(const char *fmt, ...) {} +void Panic(const char *fmt, ...) {} +void Log(const char *fmt, ...) {} +*/ +import "C" +import "unsafe" + +// MessageChannel provides a channel to pass information from/to the hypervisor +type MessageChannel *C.struct_Message_Channel + +// MessageOpen creates a new MessageChannel +func MessageOpen(proto uint32) MessageChannel { + return C.Message_Open(C.uint32(proto)) +} + +// MessageClose closes a MessageChannel +func MessageClose(c MessageChannel) bool { + status := C.Message_Close(c) + return status != 0 +} + +// MessageSend sends a request through a MessageChannel +func MessageSend(c MessageChannel, request []byte) bool { + buffer := (*C.uchar)(unsafe.Pointer(&request[0])) + status := C.Message_Send(c, buffer, (C.size_t)(C.int(len(request)))) + return status != 0 +} + +// MessageReceive receives a response through a MessageChannel +func MessageReceive(c MessageChannel) ([]byte, bool) { + var reply *C.uchar + var replyLen C.size_t + defer C.free(unsafe.Pointer(reply)) + + status := C.Message_Receive(c, &reply, &replyLen) + + res := C.GoBytes(unsafe.Pointer(reply), (C.int)(replyLen)) + return res, status != 0 +} + +// VMCheckIsVirtualWorld checks if current code is running in a VMware virtual machine +func VMCheckIsVirtualWorld() bool { + return C.VmCheck_IsVirtualWorld() != 0 +} + +// VMCheckGetVersion returns the identifiers of the current hypervisor +func VMCheckGetVersion() (uint32, uint32) { + var version C.uint32 + var typ C.uint32 + C.VmCheck_GetVersion(&version, &typ) + return uint32(version), uint32(typ) +} diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/dynbuf.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/dynbuf.c new file mode 100644 index 0000000..95b3755 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/dynbuf.c @@ -0,0 +1,439 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * dynbuf.c -- + * + * Dynamic buffers --hpreg + */ + + +#include +#include +#include + +#include "vmware.h" +#include "dynbuf.h" + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Init -- + * + * Dynamic buffer constructor --hpreg + * + * Results: + * None + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void +DynBuf_Init(DynBuf *b) // OUT: +{ + ASSERT(b); + + b->data = NULL; + b->size = 0; + b->allocated = 0; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Destroy -- + * + * Dynamic buffer destructor --hpreg + * + * Results: + * None + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void +DynBuf_Destroy(DynBuf *b) // IN/OUT: +{ + ASSERT(b); + + free(b->data); + DynBuf_Init(b); +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_AllocGet -- + * + * Retrieve a pointer to the data contained in a dynamic buffer. Return + * a copy of that data. + * + * Results: + * The pointer to the data. NULL on out of memory failure. + * + * Side effects: + * Allocates memory. + * + *----------------------------------------------------------------------------- + */ + +void * +DynBuf_AllocGet(DynBuf const *b) // IN +{ + void *new_data; + ASSERT(b); + + new_data = malloc(b->size); + if (new_data) { + memcpy(new_data, b->data, b->size); + } + + return new_data; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Attach -- + * + * Grants ownership of the specified buffer to the DynBuf + * object. If there is an existing buffer, it is freed. + * + * Results: + * None. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void +DynBuf_Attach(DynBuf *b, // IN + size_t size, // IN + void *data) // IN +{ + ASSERT(b); + ASSERT((size == 0) == (data == NULL)); + + free(b->data); + b->data = data; + b->size = b->allocated = size; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Detach -- + * + * Releases ownership of the buffer stored in the DynBuf object, + * and returns a pointer to it. + * + * Results: + * The pointer to the data. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void * +DynBuf_Detach(DynBuf *b) // IN +{ + void *data; + + ASSERT(b); + + data = b->data; + b->data = NULL; + b->allocated = 0; + + return data; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBufRealloc -- + * + * Reallocate a dynamic buffer --hpreg + * + * Results: + * TRUE on success + * FALSE on failure (not enough memory) + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +static Bool +DynBufRealloc(DynBuf *b, // IN: + size_t newAllocated) // IN: +{ + void *new_data; + + ASSERT(b); + + new_data = realloc(b->data, newAllocated); + if (new_data == NULL && newAllocated) { + /* Not enough memory */ + return FALSE; + } + + b->data = new_data; + b->allocated = newAllocated; + + return TRUE; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Enlarge -- + * + * Enlarge a dynamic buffer. The resulting dynamic buffer is guaranteed to + * be larger than the one you passed, and at least 'minSize' bytes + * large --hpreg + * + * Results: + * TRUE on success + * FALSE on failure (not enough memory) + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +DynBuf_Enlarge(DynBuf *b, // IN: + size_t minSize) // IN: +{ + size_t newAllocated; + + ASSERT(b); + + newAllocated = b->allocated + ? +#if defined(DYNBUF_DEBUG) + b->allocated + 1 +#else + /* + * Double the previously allocated size if it is less + * than 256KB; otherwise grow it linearly by 256KB + */ + (b->allocated < 256 * 1024 ? b->allocated * 2 + : b->allocated + 256 * 1024) +#endif + : +#if defined(DYNBUF_DEBUG) + 1 +#else + /* + * Initial size: 1 KB. Most buffers are smaller than + * that --hpreg + */ + 1 << 10 +#endif + ; + + if (minSize > newAllocated) { + newAllocated = minSize; + } + + /* + * Prevent integer overflow. We can use this form of checking specifically + * because a multiple by 2 is used (in the worst case). This type of + * checking does not work in the general case. + */ + + if (newAllocated < b->allocated) { + return FALSE; + } + + return DynBufRealloc(b, newAllocated); +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Append -- + * + * Append data at the end of a dynamic buffer. 'size' is the size of the + * data. If it is <= 0, no operation is performed --hpreg + * + * Results: + * TRUE on success + * FALSE on failure (not enough memory) + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +DynBuf_Append(DynBuf *b, // IN + void const *data, // IN + size_t size) // IN +{ + size_t new_size; + + ASSERT(b); + + if (size <= 0) { + return TRUE; + } + + ASSERT(data); + + new_size = b->size + size; + + if (new_size < b->size) { // Prevent integer overflow + return FALSE; + } + + if (new_size > b->allocated) { + /* Not enough room */ + if (DynBuf_Enlarge(b, new_size) == FALSE) { + return FALSE; + } + } + + memcpy(b->data + b->size, data, size); + b->size = new_size; + + return TRUE; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_SafeInternalAppend -- + * + * Append data at the end of a dynamic buffer. Memory allocation failure + * are handled the same way as Util_SafeMalloc, that is to say, with a + * Panic. + * + * Results: + * None + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +void +DynBuf_SafeInternalAppend(DynBuf *b, // IN + void const *data, // IN + size_t size, // IN + char const *file, // IN + unsigned int lineno) // IN +{ + if (!DynBuf_Append(b, data, size)) { + Panic("Unrecoverable memory allocation failure at %s:%u\n", + file, lineno); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Trim -- + * + * Reallocate a dynamic buffer to the exact size it occupies --hpreg + * + * Results: + * TRUE on success + * FALSE on failure (not enough memory) + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +DynBuf_Trim(DynBuf *b) // IN +{ + ASSERT(b); + + return DynBufRealloc(b, b->size); +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Copy -- + * + * Copies all data and metadata from src dynbuff to dest dynbuf. + * + * Dest should be an initialized DynBuf of alloced length zero + * to prevent memory leaks. + * + * Results: + * TRUE on success, FALSE on failure. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +DynBuf_Copy(DynBuf *src, // IN + DynBuf *dest) // OUT +{ + ASSERT(src); + ASSERT(dest); + ASSERT(!dest->data); + + dest->data = malloc(src->allocated); + + if (dest->data == NULL) { + return FALSE; + } + + dest->size = src->size; + dest->allocated = src->allocated; + + memcpy(dest->data, src->data, src->size); + + return TRUE; +} diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfo.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfo.c new file mode 100644 index 0000000..81c2f90 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfo.c @@ -0,0 +1,336 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * hostinfo.c -- + * + * Platform-independent code that calls into hostinfo-specific + * code. + */ + +#include "vmware.h" +#include + +#if defined(__i386__) || defined(__x86_64__) +#include "cpuid_info.h" +#endif +#include "hostinfo.h" +#include "hostinfoInt.h" +#include "util.h" +/* #include "str.h" */ +#include +#define Str_Sprintf snprintf +#include "dynbuf.h" +#include "backdoor_def.h" + +/* + * #define LOGLEVEL_MODULE hostinfo + * #include "loglevel_user.h" + */ +#define LGPFX "HOSTINFO:" + + +/* + * HostinfoOSData caches its returned value. + */ + +volatile Bool HostinfoOSNameCacheValid = FALSE; +char HostinfoCachedOSName[MAX_OS_NAME_LEN]; +char HostinfoCachedOSFullName[MAX_OS_FULLNAME_LEN]; + + +#if defined(__i386__) || defined(__x86_64__) +/* + *----------------------------------------------------------------------------- + * + * HostInfoGetCpuidStrSection -- + * + * Append a section (either low or high) of CPUID as a string in DynBuf. + * E.g. + * 00000000:00000005756E65476C65746E49656E69- + * 00000001:00000F4A000208000000649DBFEBFBFF- + * or + * 80000000:80000008000000000000000000000000- + * 80000001:00000000000000000000000120100000- + * 80000008:00003024000000000000000000000000- + * + * The returned eax of args[0] is used to determine the upper bound for + * the following input arguments. And the input args should be in + * ascending order. + * + * Results: + * None. The string will be appended in buf. + * + * Side effect: + * None + * + *----------------------------------------------------------------------------- + */ + +static void +HostInfoGetCpuidStrSection(const uint32 args[], // IN: input eax arguments + const size_t args_size, // IN: size of the argument array + DynBuf *buf) // IN/OUT: result string in DynBuf +{ + static const char format[] = "%08X:%08X%08X%08X%08X-"; + CPUIDRegs reg; + uint32 max_arg; + char temp[64]; + int i; + + __GET_CPUID(args[0], ®); + max_arg = reg.eax; + if (max_arg < args[0]) { + Warning(LGPFX" No CPUID information available. Based = %08X.\n", + args[0]); + return; + } + DynBuf_Append(buf, temp, + Str_Sprintf(temp, sizeof temp, format, args[0], reg.eax, + reg.ebx, reg.ecx, reg.edx)); + + for (i = 1; i < args_size && args[i] <= max_arg; i++) { + ASSERT(args[i] > args[i - 1]); // Ascending order. + __GET_CPUID(args[i], ®); + + DynBuf_Append(buf, temp, + Str_Sprintf(temp, sizeof temp, format, args[i], reg.eax, + reg.ebx, reg.ecx, reg.edx)); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * Hostinfo_GetCpuidStr -- + * + * Get the basic and extended CPUID as a string. E.g. + * 00000000:00000005756E65476C65746E49656E69- + * 00000001:00000F4A000208000000649DBFEBFBFF- + * 80000000:80000008000000000000000000000000- + * 80000001:00000000000000000000000120100000- + * 80000008:00003024000000000000000000000000 + * + * If the extended CPUID is not available, only returns the basic CPUID. + * + * Results: + * The CPUID string if the processor supports the CPUID instruction and + * this is a processor we recognize. It should never fail, since it + * would at least return leaf 0. Caller needs to free the returned string. + * + * Side effect: + * None + * + *----------------------------------------------------------------------------- + */ + +char * +Hostinfo_GetCpuidStr(void) +{ + static const uint32 basic_args[] = {0x0, 0x1, 0xa}; + static const uint32 extended_args[] = {0x80000000, 0x80000001, 0x80000008}; + DynBuf buf; + char *result; + + DynBuf_Init(&buf); + + HostInfoGetCpuidStrSection(basic_args, ARRAYSIZE(basic_args), &buf); + HostInfoGetCpuidStrSection(extended_args, ARRAYSIZE(extended_args), &buf); + + // Trim buffer and set NULL character to replace last '-'. + DynBuf_Trim(&buf); + result = (char*)DynBuf_Get(&buf); + ASSERT(result && result[0]); // We should at least get result from eax = 0x0. + result[DynBuf_GetSize(&buf) - 1] = '\0'; + + return DynBuf_Detach(&buf); +} +#endif // defined(__i386__) || defined(__x86_64__) + + +/* + *----------------------------------------------------------------------------- + * + * Hostinfo_GetCpuid -- + * + * Get cpuid information for a CPU. Which CPU the information is for + * depends on the OS scheduler. We are assuming that all CPUs in + * the system have identical numbers of cores and threads. + * + * Results: + * TRUE if the processor supports the cpuid instruction and this + * is a process we recognize, FALSE otherwise. + * + * Side effect: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +Hostinfo_GetCpuid(HostinfoCpuIdInfo *info) // OUT +{ +#if defined(__i386__) || defined(__x86_64__) + CPUIDSummary cpuid; + CPUIDRegs id0; + + /* + * Can't do cpuid = {0} as an initializer above because gcc throws + * some idiotic warning. + */ + + memset(&cpuid, 0, sizeof(cpuid)); + + /* + * Get basic and extended CPUID info. + */ + + __GET_CPUID(0, &id0); + + cpuid.id0.numEntries = id0.eax; + + if (0 == cpuid.id0.numEntries) { + Warning(LGPFX" No CPUID information available.\n"); + + return FALSE; + } + + *(uint32*)(cpuid.id0.name + 0) = id0.ebx; + *(uint32*)(cpuid.id0.name + 4) = id0.edx; + *(uint32*)(cpuid.id0.name + 8) = id0.ecx; + *(uint32*)(cpuid.id0.name + 12) = 0; + + __GET_CPUID(1, (CPUIDRegs*)&cpuid.id1); + __GET_CPUID(0xa, (CPUIDRegs*)&cpuid.ida); + __GET_CPUID(0x80000000, (CPUIDRegs*)&cpuid.id80); + __GET_CPUID(0x80000001, (CPUIDRegs*)&cpuid.id81); + __GET_CPUID(0x80000008, (CPUIDRegs*)&cpuid.id88); + + /* + * Calculate vendor information. + */ + + if (0 == strcmp(cpuid.id0.name, CPUID_INTEL_VENDOR_STRING_FIXED)) { + info->vendor = CPUID_VENDOR_INTEL; + } else if (strcmp(cpuid.id0.name, CPUID_AMD_VENDOR_STRING_FIXED) == 0) { + info->vendor = CPUID_VENDOR_AMD; + } else { + info->vendor = CPUID_VENDOR_UNKNOWN; + } + /* + * Pull out versioning and feature information. + */ + + info->version = cpuid.id1.version; + info->family = CPUID_GET(1, EAX, FAMILY, cpuid.id1.version); + info->model = CPUID_GET(1, EAX, MODEL, cpuid.id1.version); + info->stepping = CPUID_GET(1, EAX, STEPPING, cpuid.id1.version); + info->type = (cpuid.id1.version >> 12) & 0x0003; + + info->extfeatures = cpuid.id1.ecxFeatures; + info->features = cpuid.id1.edxFeatures; + + return TRUE; +#else // defined(__i386__) || defined(__x86_64__) + return FALSE; +#endif // defined(__i386__) || defined(__x86_64__) +} + + +/* + *----------------------------------------------------------------------------- + * + * Hostinfo_GetOSName -- + * + * Query the operating system and build a string to identify it. + * + * Examples: + * Windows: (Build ) + * example: Windows XP Professional Service Pack 2 (Build 2600) + * + * Linux: + * example: Linux 2.4.18-3 Red Hat Linux release 7.3 (Valhalla) + * + * Mac OS: () + * example: Mac OS X 10.8.5 (12F45) Darwin 12.5.0 + * + * Return value: + * NULL Unable to obtain the OS name. + * !NULL The OS name. The caller is responsible for freeing it. + * + * Side effects: + * Memory is allocated. + * + *----------------------------------------------------------------------------- + */ + +/* + * char * + * Hostinfo_GetOSName(void) + * { + * char *name; + * Bool data = HostinfoOSNameCacheValid ? TRUE : HostinfoOSData(); + * + * if (data) { + * name = Util_SafeStrdup(HostinfoCachedOSFullName); + * } else { + * name = NULL; + * } + * + * return name; + * } + */ + + + +/* + *----------------------------------------------------------------------------- + * + * Hostinfo_GetOSGuestString -- + * + * Query the operating system and build a string to identify it. The + * returned string is the same as you'd see in a VM's .vmx file. + * + * Return value: + * NULL Unable to obtain the OS name. + * !NULL The OS name. The caller is responsible for freeing it. + * + * Side effects: + * Memory is allocated. + * + *----------------------------------------------------------------------------- + */ + +/* + * char * + * Hostinfo_GetOSGuestString(void) + * { + * char *name; + * Bool data = HostinfoOSNameCacheValid ? TRUE : HostinfoOSData(); + * + * if (data) { + * name = Util_SafeStrdup(HostinfoCachedOSName); + * } else { + * name = NULL; + * } + * + * return name; + * } + */ + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfoHV.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfoHV.c new file mode 100644 index 0000000..ec6eb4d --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/hostinfoHV.c @@ -0,0 +1,686 @@ +/********************************************************* + * Copyright (C) 2011-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * hostinfoHV.c -- + * + * Code to detect different hypervisors and features. + */ + +#include +#include "vmware.h" +#if defined(__i386__) || defined(__x86_64__) +# include "cpuid_info.h" +# include "backdoor_def.h" +# include "backdoor_types.h" +#endif +#include "hostinfo.h" +#include "util.h" + +#define LGPFX "HOSTINFO:" +/* + * #define LOGLEVEL_MODULE hostinfo + * #include "loglevel_user.h" + */ + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_HypervisorCPUIDSig -- + * + * Get the hypervisor signature string from CPUID. + * + * Results: + * Unqualified 16 byte nul-terminated hypervisor string + * String may contain garbage and caller must free + * + * Side effects: + * None + * + *---------------------------------------------------------------------- + */ + +char * +Hostinfo_HypervisorCPUIDSig(void) +{ + uint32 *name = NULL; +#if defined(__i386__) || defined(__x86_64__) + CPUIDRegs regs; + + __GET_CPUID(1, ®s); + if (!CPUID_ISSET(1, ECX, HYPERVISOR, regs.ecx)) { + return NULL; + } + + regs.ebx = 0; + regs.ecx = 0; + regs.edx = 0; + + __GET_CPUID(0x40000000, ®s); + + if (regs.eax < 0x40000000) { + Log(LGPFX" CPUID hypervisor bit is set, but no " + "hypervisor vendor signature is present\n"); + } + + name = Util_SafeMalloc(4 * sizeof *name); + + name[0] = regs.ebx; + name[1] = regs.ecx; + name[2] = regs.edx; + name[3] = 0; +#endif // defined(__i386__) || defined(__x86_64__) + + return (char *)name; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_TouchXen -- + * + * Check for Xen. + * + * Official way is to call Hostinfo_HypervisorCPUIDSig(), which + * returns a hypervisor string. This is a secondary check + * that guards against a backdoor failure. See PR156185, + * http://xenbits.xensource.com/xen-unstable.hg?file/6a383beedf83/tools/misc/xen-detect.c + * (Canonical way is /proc/xen, but CPUID is better). + * + * Results: + * TRUE if we are running in a Xen dom0 or domU. + * Linux: + * Illegal instruction exception on real hardware. + * Obscure Xen implementations might return FALSE. + * Windows: + * FALSE on real hardware. + * + * Side effects: + * Linux: Will raise exception on native hardware. + * Windows: None. + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_TouchXen(void) +{ +#if defined(linux) && (defined(__i386__) || defined(__x86_64__)) +#define XEN_CPUID 0x40000000 + CPUIDRegs regs; + uint32 name[4]; + + /* + * PV mode: ud2a "xen" cpuid (faults on native hardware). + * (Only Linux can run PV, so skip others here). + * Since PV cannot trap CPUID, this is a Xen hook. + */ + + regs.eax = XEN_CPUID; + __asm__ __volatile__( + "xchgl %%ebx, %0" "\n\t" + "ud2a ; .ascii \"xen\" ; cpuid" "\n\t" + "xchgl %%ebx, %0" + : "=&r" (regs.ebx), "=&c" (regs.ecx), "=&d" (regs.edx) + : "a" (regs.eax) + ); + + name[0] = regs.ebx; + name[1] = regs.ecx; + name[2] = regs.edx; + name[3] = 0; + + if (0 == strcmp(CPUID_XEN_HYPERVISOR_VENDOR_STRING, (const char*)name)) { + return TRUE; + } + + /* Passed checks. But native and anything non-Xen would #UD before here. */ + NOT_TESTED(); + Log("Xen detected but hypervisor unrecognized (Xen variant?)\n"); + Log("CPUID 0x4000 0000: eax=%x ebx=%x ecx=%x edx=%x\n", + regs.eax, regs.ebx, regs.ecx, regs.edx); +#endif + + return FALSE; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_SLC64Supported -- + * + * Access the backdoor with an SLC64 control query. This is used + * to determine if we are running in a VM that supports SLC64. + * This function should only be called after determining that the + * backdoor is present with Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports SLC64. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_SLC64Supported(void) +{ +#if defined(__i386__) || defined(__x86_64__) + return Hostinfo_VCPUInfoBackdoor(BDOOR_CMD_VCPU_SLC64); +#else + return FALSE; +#endif +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_NestedHVReplaySupported -- + * + * Access the backdoor with a HV replay control query. This is used + * to determine if we are running in a VM that supports nested HV replay. + * This function should only be called after determining that the + * backdoor is present with Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports nexted HV replay. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_NestedHVReplaySupported(void) +{ +#if defined(__i386__) || defined(__x86_64__) + return Hostinfo_VCPUInfoBackdoor(BDOOR_CMD_VCPU_HV_REPLAY_OK); +#else + return FALSE; +#endif +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_SynchronizedVTSCs -- + * + * Access the backdoor to determine if the VCPUs' TSCs are + * synchronized. + * + * Results: + * TRUE if the outer VM provides synchronized VTSCs. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_SynchronizedVTSCs(void) +{ +#if defined(__i386__) || defined(__x86_64__) + return Hostinfo_VCPUInfoBackdoor(BDOOR_CMD_VCPU_SYNC_VTSCS); +#else + return FALSE; +#endif +} + + +#if defined(_WIN32) + +#if defined(_WIN64) +// from touchBackdoorMasm64.asm +void Hostinfo_BackdoorInOut(Backdoor_proto *myBp); +#endif + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_TouchBackDoor -- + * + * Access the backdoor. This is used to determine if we are + * running in a VM or on a physical host. On a physical host + * this should generate a GP which we catch and thereby determine + * that we are not in a VM. However some OSes do not handle the + * GP correctly and the process continues running returning garbage. + * In this case we check the EBX register which should be + * BDOOR_MAGIC if the IN was handled in a VM. Based on this we + * return either TRUE or FALSE. + * + * Results: + * TRUE if we succesfully accessed the backdoor, FALSE or segfault + * if not. + * + * Side effects: + * Exception if not in a VM. + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_TouchBackDoor(void) +{ + uint32 ebxval; + +#if defined(_WIN64) + Backdoor_proto bp; + + bp.in.ax.quad = BDOOR_MAGIC; + bp.in.size = ~BDOOR_MAGIC; + bp.in.cx.quad = BDOOR_CMD_GETVERSION; + bp.in.dx.quad = BDOOR_PORT; + + Hostinfo_BackdoorInOut(&bp); + + ebxval = bp.out.bx.words.low; +#else // _WIN64 + _asm { + push edx + push ecx + push ebx + mov ecx, BDOOR_CMD_GETVERSION + mov ebx, ~BDOOR_MAGIC + mov eax, BDOOR_MAGIC + mov dx, BDOOR_PORT + in eax, dx + mov ebxval, ebx + pop ebx + pop ecx + pop edx + } +#endif // _WIN64 + + return (ebxval == BDOOR_MAGIC) ? TRUE : FALSE; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_TouchVirtualPC -- + * + * Access MS Virtual PC's backdoor. This is used to determine if + * we are running in a MS Virtual PC or on a physical host. Works + * the same as Hostinfo_TouchBackDoor, except the entry to MS VPC + * is an invalid opcode instead or writing to a port. Since + * MS VPC is 32-bit only, the WIN64 path returns FALSE. + * See: See: http://www.codeproject.com/KB/system/VmDetect.aspx + * + * Results: + * TRUE if we succesfully accessed MS Virtual PC, FALSE or + * segfault if not. + * + * Side effects: + * Exception if not in a VM. + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_TouchVirtualPC(void) +{ +#if defined(_WIN64) + return FALSE; // MS Virtual PC is 32-bit only +#else // _WIN32 + uint32 ebxval; + + _asm { + push ebx + mov ebx, 0 + + mov eax, 1 // Virtual PC function number + + // execute invalid opcode to call into MS Virtual PC + + __emit 0Fh + __emit 3Fh + __emit 07h + __emit 0Bh + + mov ebxval, ebx + pop ebx + } + return !ebxval; // ebx is zero if inside Virtual PC +#endif +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_NestingSupported -- + * + * Access the backdoor with a nesting control query. This is used + * to determine if we are running in a VM that supports nesting. + * This function should only be called after determining that the + * backdoor is present with Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports nesting. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_NestingSupported(void) +{ + uint32 cmd = NESTING_CONTROL_QUERY << 16 | BDOOR_CMD_NESTING_CONTROL; + uint32 result; + +#if defined(_WIN64) + Backdoor_proto bp; + + bp.in.ax.quad = BDOOR_MAGIC; + bp.in.cx.quad = cmd; + bp.in.dx.quad = BDOOR_PORT; + + Hostinfo_BackdoorInOut(&bp); + + result = bp.out.ax.words.low; +#else + _asm { + push edx + push ecx + mov ecx, cmd + mov eax, BDOOR_MAGIC + mov dx, BDOOR_PORT + in eax, dx + mov result, eax + pop ecx + pop edx + } +#endif + + if (result >= NESTING_CONTROL_QUERY && result != ~0U) { + return TRUE; + } + return FALSE; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_VCPUInfoBackdoor -- + * + * Access the backdoor with an VCPU info query. This is used to + * determine whether a VCPU supports a particular feature, + * determined by 'bit'. This function should only be called after + * determining that the backdoor is present with + * Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports the feature. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_VCPUInfoBackdoor(unsigned bit) +{ + uint32 cmd = BDOOR_CMD_GET_VCPU_INFO; + uint32 result; + +#if defined(_WIN64) + Backdoor_proto bp; + + bp.in.ax.quad = BDOOR_MAGIC; + bp.in.cx.quad = cmd; + bp.in.dx.quad = BDOOR_PORT; + + Hostinfo_BackdoorInOut(&bp); + + result = bp.out.ax.words.low; +#else + _asm { + push edx + push ecx + mov ecx, cmd + mov eax, BDOOR_MAGIC + mov dx, BDOOR_PORT + in eax, dx + mov result, eax + pop ecx + pop edx + } +#endif + /* If reserved bit is 1, this command wasn't implemented. */ + return (result & (1 << BDOOR_CMD_VCPU_RESERVED)) == 0 && + (result & (1 << bit)) != 0; +} + + +#else + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_TouchBackDoor -- + * + * Access the backdoor. This is used to determine if we are + * running in a VM or on a physical host. On a physical host + * this should generate a GP which we catch and thereby determine + * that we are not in a VM. However some OSes do not handle the + * GP correctly and the process continues running returning garbage. + * In this case we check the EBX register which should be + * BDOOR_MAGIC if the IN was handled in a VM. Based on this we + * return either TRUE or FALSE. + * + * Results: + * TRUE if we succesfully accessed the backdoor, FALSE or segfault + * if not. + * + * Side effects: + * Exception if not in a VM. + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_TouchBackDoor(void) +{ +#if defined(__i386__) || defined(__x86_64__) + uint32 eax; + uint32 ebx; + uint32 ecx; + + __asm__ __volatile__( +# if defined __PIC__ && !vm_x86_64 // %ebx is reserved by the compiler. + "xchgl %%ebx, %1" "\n\t" + "inl %%dx, %%eax" "\n\t" + "xchgl %%ebx, %1" + : "=a" (eax), + "=&rm" (ebx), +# else + "inl %%dx, %%eax" + : "=a" (eax), + "=b" (ebx), +# endif + "=c" (ecx) + : "0" (BDOOR_MAGIC), + "1" (~BDOOR_MAGIC), + "2" (BDOOR_CMD_GETVERSION), + "d" (BDOOR_PORT) + ); + if (ebx == BDOOR_MAGIC) { + return TRUE; + } +#endif + + return FALSE; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_TouchVirtualPC -- + * + * Access MS Virtual PC's backdoor. This is used to determine if + * we are running in a MS Virtual PC or on a physical host. Works + * the same as Hostinfo_TouchBackDoor, except the entry to MS VPC + * is an invalid opcode instead or writing to a port. Since + * MS VPC is 32-bit only, the 64-bit path returns FALSE. + * See: http://www.codeproject.com/KB/system/VmDetect.aspx + * + * Results: + * TRUE if we succesfully accessed MS Virtual PC, FALSE or + * segfault if not. + * + * Side effects: + * Exception if not in a VM. + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_TouchVirtualPC(void) +{ +#if defined vm_x86_64 + return FALSE; +#else + + uint32 ebxval; + + __asm__ __volatile__ ( +# if defined __PIC__ // %ebx is reserved by the compiler. + "xchgl %%ebx, %1" "\n\t" + ".long 0x0B073F0F" "\n\t" + "xchgl %%ebx, %1" + : "=&rm" (ebxval) + : "a" (1), + "0" (0) +# else + ".long 0x0B073F0F" + : "=b" (ebxval) + : "a" (1), + "b" (0) +# endif + ); + return !ebxval; // %%ebx is zero if inside Virtual PC +#endif +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_NestingSupported -- + * + * Access the backdoor with a nesting control query. This is used + * to determine if we are running inside a VM that supports nesting. + * This function should only be called after determining that the + * backdoor is present with Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports nesting. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_NestingSupported(void) +{ +#if defined(__i386__) || defined(__x86_64__) + uint32 cmd = NESTING_CONTROL_QUERY << 16 | BDOOR_CMD_NESTING_CONTROL; + uint32 result; + + __asm__ __volatile__( + "inl %%dx, %%eax" + : "=a" (result) + : "0" (BDOOR_MAGIC), + "c" (cmd), + "d" (BDOOR_PORT) + ); + + if (result >= NESTING_CONTROL_QUERY && result != ~0U) { + return TRUE; + } +#endif + + return FALSE; +} + + +/* + *---------------------------------------------------------------------- + * + * Hostinfo_VCPUInfoBackdoor -- + * + * Access the backdoor with an VCPU info query. This is used to + * determine whether a VCPU supports a particular feature, + * determined by 'bit'. This function should only be called after + * determining that the backdoor is present with + * Hostinfo_TouchBackdoor(). + * + * Results: + * TRUE if the outer VM supports the feature. + * FALSE otherwise. + * + * Side effects: + * Exception if not in a VM, so don't do that! + * + *---------------------------------------------------------------------- + */ + +Bool +Hostinfo_VCPUInfoBackdoor(unsigned bit) +{ +#if defined(__i386__) || defined(__x86_64__) + uint32 result; + __asm__ __volatile__( + "inl %%dx, %%eax" + : "=a" (result) + : "0" (BDOOR_MAGIC), + "c" (BDOOR_CMD_GET_VCPU_INFO), + "d" (BDOOR_PORT) + ); + /* If reserved bit is 1, this command wasn't implemented. */ + return (result & (1 << BDOOR_CMD_VCPU_RESERVED)) == 0 && + (result & (1 << bit)) != 0; +#endif + return FALSE; +} + +#endif + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/message.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/message.c new file mode 100644 index 0000000..506fe42 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/message.c @@ -0,0 +1,605 @@ +/********************************************************* + * Copyright (C) 1999-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * message.c -- + * + * Second layer of the internal communication channel between guest + * applications and vmware + * + * Build a generic messaging system between guest applications and vmware. + * + * The protocol is not completely symmetrical, because: + * . basic requests can only be sent by guest applications (when vmware + * wants to post a message to a guest application, the message will be + * really fetched only when the guest application will poll for new + * available messages) + * . several guest applications can talk to vmware, while the contrary is + * not true + * + * Operations that are not atomic (in terms of number of backdoor calls) + * can be aborted by vmware if a checkpoint/restore occurs in the middle of + * such an operation. This layer takes care of retrying those operations. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(__KERNEL__) || defined(_KERNEL) || defined(KERNEL) +# include "kernelStubs.h" +#else +# include +# include +# include "debug.h" +#endif + +#include "backdoor_def.h" +#include "guest_msg_def.h" +#include "backdoor.h" +#include "message.h" + + +#if defined(MESSAGE_DEBUG) +# define MESSAGE_LOG(...) Warning(__VA_ARGS__) +#else +# define MESSAGE_LOG(...) +#endif + +/* The channel object */ +struct Message_Channel { + /* Identifier */ + uint16 id; + + /* Reception buffer */ + /* Data */ + unsigned char *in; + /* Allocated size */ + size_t inAlloc; + + /* The cookie */ + uint32 cookieHigh; + uint32 cookieLow; +}; + + +/* + *----------------------------------------------------------------------------- + * + * Message_Open -- + * + * Open a communication channel + * + * Result: + * An allocated Message_Channel on success + * NULL on failure + * + * Side-effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Message_Channel * +Message_Open(uint32 proto) // IN +{ + Message_Channel *chan; + uint32 flags; + Backdoor_proto bp; + + chan = (Message_Channel *)malloc(sizeof(*chan)); + if (chan == NULL) { + goto error_quit; + } + + flags = GUESTMSG_FLAG_COOKIE; +retry: + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_OPEN; + /* IN: Magic number of the protocol and flags */ + bp.in.size = proto | flags; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if (flags) { + /* Cookies not supported. Fall back to no cookie. --hpreg */ + flags = 0; + goto retry; + } + + MESSAGE_LOG("Message: Unable to open a communication channel\n"); + goto error_quit; + } + + /* OUT: Id and cookie */ + chan->id = bp.in.dx.halfs.high; + chan->cookieHigh = bp.out.si.word; + chan->cookieLow = bp.out.di.word; + + /* Initialize the channel */ + chan->in = NULL; + chan->inAlloc = 0; + + return chan; + +error_quit: + free(chan); + chan = NULL; + return NULL; +} + + +/* + *----------------------------------------------------------------------------- + * + * Message_Send -- + * + * Send a message over a communication channel + * + * Result: + * TRUE on success + * FALSE on failure (the message is discarded by vmware) + * + * Side-effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +Message_Send(Message_Channel *chan, // IN/OUT + const unsigned char *buf, // IN + size_t bufSize) // IN +{ + const unsigned char *myBuf; + size_t myBufSize; + Backdoor_proto bp; + +retry: + myBuf = buf; + myBufSize = bufSize; + + /* + * Send the size. + */ + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_SENDSIZE; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + /* IN: Size */ + bp.in.size = myBufSize; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + MESSAGE_LOG("Message: Unable to send a message over the communication " + "channel %u\n", chan->id); + return FALSE; + } + + if (bp.in.cx.halfs.high & MESSAGE_STATUS_HB) { + /* + * High-bandwidth backdoor port supported. Send the message in one + * backdoor operation. --hpreg + */ + + if (myBufSize) { + Backdoor_proto_hb bphb; + + bphb.in.bx.halfs.low = BDOORHB_CMD_MESSAGE; + bphb.in.bx.halfs.high = MESSAGE_STATUS_SUCCESS; + bphb.in.dx.halfs.high = chan->id; + bphb.in.bp.word = chan->cookieHigh; + bphb.in.dstAddr = chan->cookieLow; + bphb.in.size = myBufSize; + bphb.in.srcAddr = (uintptr_t) myBuf; + Backdoor_HbOut(&bphb); + if ((bphb.in.bx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if ((bphb.in.bx.halfs.high & MESSAGE_STATUS_CPT) != 0) { + /* A checkpoint occurred. Retry the operation. --hpreg */ + goto retry; + } + + MESSAGE_LOG("Message: Unable to send a message over the " + "communication channel %u\n", chan->id); + return FALSE; + } + } + } else { + /* + * High-bandwidth backdoor port not supported. Send the message, 4 bytes + * at a time. --hpreg + */ + + for (;;) { + if (myBufSize == 0) { + /* We are done */ + break; + } + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_SENDPAYLOAD; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + /* IN: Piece of message */ + /* + * Beware in case we are not allowed to read extra bytes beyond the + * end of the buffer. + */ + switch (myBufSize) { + case 1: + bp.in.size = myBuf[0]; + myBufSize -= 1; + break; + case 2: + bp.in.size = myBuf[0] | myBuf[1] << 8; + myBufSize -= 2; + break; + case 3: + bp.in.size = myBuf[0] | myBuf[1] << 8 | myBuf[2] << 16; + myBufSize -= 3; + break; + default: + bp.in.size = *(const uint32 *)myBuf; + myBufSize -= 4; + break; + } + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_CPT) != 0) { + /* A checkpoint occurred. Retry the operation. --hpreg */ + goto retry; + } + + MESSAGE_LOG("Message: Unable to send a message over the " + "communication channel %u\n", chan->id); + return FALSE; + } + + myBuf += 4; + } + } + + return TRUE; +} + + +/* + *----------------------------------------------------------------------------- + * + * Message_Receive -- + * + * If vmware has posted a message for this channel, retrieve it + * + * Result: + * TRUE on success (bufSize is 0 if there is no message) + * FALSE on failure + * + * Side-effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +Message_Receive(Message_Channel *chan, // IN/OUT + unsigned char **buf, // OUT + size_t *bufSize) // OUT +{ + Backdoor_proto bp; + size_t myBufSize; + unsigned char *myBuf; + +retry: + /* + * Is there a message waiting for our retrieval? + */ + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_RECVSIZE; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + MESSAGE_LOG("Message: Unable to poll for messages over the " + "communication channel %u\n", chan->id); + return FALSE; + } + + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_DORECV) == 0) { + /* No message to retrieve */ + *bufSize = 0; + return TRUE; + } + + /* + * Receive the size. + */ + + /* OUT: Type */ + if (bp.in.dx.halfs.high != MESSAGE_TYPE_SENDSIZE) { + MESSAGE_LOG("Message: Protocol error. Expected a " + "MESSAGE_TYPE_SENDSIZE request from vmware\n"); + return FALSE; + } + + /* OUT: Size */ + myBufSize = bp.out.bx.word; + + /* + * Allocate an extra byte for a trailing NUL character. The code that will + * deal with this message may not know about binary strings, and may expect + * a C string instead. --hpreg + */ + if (myBufSize + 1 > chan->inAlloc) { + myBuf = (unsigned char *)realloc(chan->in, myBufSize + 1); + if (myBuf == NULL) { + MESSAGE_LOG("Message: Not enough memory to receive a message over " + "the communication channel %u\n", chan->id); + goto error_quit; + } + + chan->in = myBuf; + chan->inAlloc = myBufSize + 1; + } + *bufSize = myBufSize; + myBuf = *buf = chan->in; + + if (bp.in.cx.halfs.high & MESSAGE_STATUS_HB) { + /* + * High-bandwidth backdoor port supported. Receive the message in one + * backdoor operation. --hpreg + */ + + if (myBufSize) { + Backdoor_proto_hb bphb; + + bphb.in.bx.halfs.low = BDOORHB_CMD_MESSAGE; + bphb.in.bx.halfs.high = MESSAGE_STATUS_SUCCESS; + bphb.in.dx.halfs.high = chan->id; + bphb.in.srcAddr = chan->cookieHigh; + bphb.in.bp.word = chan->cookieLow; + bphb.in.size = myBufSize; + bphb.in.dstAddr = (uintptr_t) myBuf; + Backdoor_HbIn(&bphb); + if ((bphb.in.bx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if ((bphb.in.bx.halfs.high & MESSAGE_STATUS_CPT) != 0) { + /* A checkpoint occurred. Retry the operation. --hpreg */ + goto retry; + } + + MESSAGE_LOG("Message: Unable to receive a message over the " + "communication channel %u\n", chan->id); + goto error_quit; + } + } + } else { + /* + * High-bandwidth backdoor port not supported. Receive the message, 4 + * bytes at a time. --hpreg + */ + + for (;;) { + if (myBufSize == 0) { + /* We are done */ + break; + } + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_RECVPAYLOAD; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + /* IN: Status for the previous request (that succeeded) */ + bp.in.size = MESSAGE_STATUS_SUCCESS; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_CPT) != 0) { + /* A checkpoint occurred. Retry the operation. --hpreg */ + goto retry; + } + + MESSAGE_LOG("Message: Unable to receive a message over the " + "communication channel %u\n", chan->id); + goto error_quit; + } + + /* OUT: Type */ + if (bp.in.dx.halfs.high != MESSAGE_TYPE_SENDPAYLOAD) { + MESSAGE_LOG("Message: Protocol error. Expected a " + "MESSAGE_TYPE_SENDPAYLOAD from vmware\n"); + goto error_quit; + } + + /* OUT: Piece of message */ + /* + * Beware in case we are not allowed to write extra bytes beyond the + * end of the buffer. --hpreg + */ + switch (myBufSize) { + case 1: + myBuf[0] = bp.out.bx.word & 0xff; + myBufSize -= 1; + break; + case 2: + myBuf[0] = bp.out.bx.word & 0xff; + myBuf[1] = (bp.out.bx.word >> 8) & 0xff; + myBufSize -= 2; + break; + case 3: + myBuf[0] = bp.out.bx.word & 0xff; + myBuf[1] = (bp.out.bx.word >> 8) & 0xff; + myBuf[2] = (bp.out.bx.word >> 16) & 0xff; + myBufSize -= 3; + break; + default: + *(uint32 *)myBuf = bp.out.bx.word; + myBufSize -= 4; + break; + } + + myBuf += 4; + } + } + + /* Write a trailing NUL just after the message. --hpreg */ + chan->in[*bufSize] = '\0'; + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_RECVSTATUS; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + /* IN: Status for the previous request (that succeeded) */ + bp.in.size = MESSAGE_STATUS_SUCCESS; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_CPT) != 0) { + /* A checkpoint occurred. Retry the operation. --hpreg */ + goto retry; + } + + MESSAGE_LOG("Message: Unable to receive a message over the " + "communication channel %u\n", chan->id); + goto error_quit; + } + + return TRUE; + +error_quit: + /* IN: Type */ + if (myBufSize == 0) { + bp.in.cx.halfs.high = MESSAGE_TYPE_RECVSTATUS; + } else { + bp.in.cx.halfs.high = MESSAGE_TYPE_RECVPAYLOAD; + } + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + /* IN: Status for the previous request (that failed) */ + bp.in.size = 0; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + MESSAGE_LOG("Message: Unable to signal an error of reception over the " + "communication channel %u\n", chan->id); + return FALSE; + } + + return FALSE; +} + + +/* + *----------------------------------------------------------------------------- + * + * Message_Close -- + * + * Close a communication channel + * + * Result: + * TRUE on success, the channel is destroyed + * FALSE on failure + * + * Side-effects: + * None + * + *----------------------------------------------------------------------------- + */ + +Bool +Message_Close(Message_Channel *chan) // IN/OUT +{ + Backdoor_proto bp; + Bool ret = TRUE; + + /* IN: Type */ + bp.in.cx.halfs.high = MESSAGE_TYPE_CLOSE; + /* IN: Id and cookie */ + bp.in.dx.halfs.high = chan->id; + bp.in.si.word = chan->cookieHigh; + bp.in.di.word = chan->cookieLow; + + bp.in.cx.halfs.low = BDOOR_CMD_MESSAGE; + Backdoor(&bp); + + /* OUT: Status */ + if ((bp.in.cx.halfs.high & MESSAGE_STATUS_SUCCESS) == 0) { + MESSAGE_LOG("Message: Unable to close the communication channel %u\n", + chan->id); + ret = FALSE; + } + + free(chan->in); + chan->in = NULL; + + free(chan); + return ret; +} + +#ifdef __cplusplus +} +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/utilMem.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/utilMem.c new file mode 100644 index 0000000..a527cfa --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/utilMem.c @@ -0,0 +1,416 @@ +/********************************************************* + * Copyright (C) 2009-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * utilMem.c -- + * + * misc util functions + */ + +#ifdef _WIN32 +#include +#endif +#include +#include +#include + +#include "vm_assert.h" +#include "util.h" + +#ifdef __APPLE__ +#include +#if !defined TARGET_OS_IPHONE +#define TARGET_OS_IPHONE 0 +#endif +#endif + +static NORETURN void UtilAllocationFailure0(void); +static NORETURN void UtilAllocationFailure1(int bugNumber, + const char *file, int lineno); + + +static void +UtilAllocationFailure0(void) +{ + Panic("Unrecoverable memory allocation failure\n"); +} + + +static void +UtilAllocationFailure1(int bugNumber, const char *file, int lineno) +{ + if (bugNumber == -1) { + Panic("Unrecoverable memory allocation failure at %s:%d\n", + file, lineno); + } else { + Panic("Unrecoverable memory allocation failure at %s:%d. Bug " + "number: %d\n", file, lineno, bugNumber); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * UtilSafeMalloc0 -- + * UtilSafeMalloc1 -- + * Helper function for malloc + * + * Results: + * Pointer to the dynamically allocated memory. + * + * Side effects: + * May Panic if ran out of memory. + * + *----------------------------------------------------------------------------- + */ + +void * +UtilSafeMalloc0(size_t size) // IN: +{ + void *result = malloc(size); + if (result == NULL && size != 0) { + UtilAllocationFailure0(); + } + return result; +} + + +void * +UtilSafeMalloc1(size_t size, // IN: + int bugNumber, // IN: + const char *file, // IN: + int lineno) // IN: +{ + void *result = malloc(size); + if (result == NULL && size != 0) { + UtilAllocationFailure1(bugNumber, file, lineno); + } + return result; +} + + +/* + *----------------------------------------------------------------------------- + * + * UtilSafeRealloc0 -- + * UtilSafeRealloc1 -- + * Helper function for realloc + * + * Results: + * Pointer to the dynamically allocated memory. + * + * Side effects: + * May Panic if ran out of memory. + * + *----------------------------------------------------------------------------- + */ + +void * +UtilSafeRealloc0(void *ptr, // IN: + size_t size) // IN: +{ + void *result = realloc(ptr, size); + if (result == NULL && size != 0) { + UtilAllocationFailure0(); + } + return result; +} + + +void * +UtilSafeRealloc1(void *ptr, // IN: + size_t size, // IN: + int bugNumber, // IN: + const char *file, // IN: + int lineno) // IN: +{ + void *result = realloc(ptr, size); + if (result == NULL && size != 0) { + UtilAllocationFailure1(bugNumber, file, lineno); + } + return result; +} + + +/* + *----------------------------------------------------------------------------- + * + * UtilSafeCalloc0 -- + * UtilSafeCalloc1 -- + * Helper function for calloc + * + * Results: + * Pointer to the dynamically allocated memory. + * + * Side effects: + * May Panic if ran out of memory. + * + *----------------------------------------------------------------------------- + */ + +void * +UtilSafeCalloc0(size_t nmemb, // IN: + size_t size) // IN: +{ + void *result = calloc(nmemb, size); + if (result == NULL && nmemb != 0 && size != 0) { + UtilAllocationFailure0(); + } + return result; +} + + +void * +UtilSafeCalloc1(size_t nmemb, // IN: + size_t size, // IN: + int bugNumber, // IN: + const char *file, // IN: + int lineno) // IN: +{ + void *result = calloc(nmemb, size); + if (result == NULL && nmemb != 0 && size != 0) { + UtilAllocationFailure1(bugNumber, file, lineno); + } + return result; +} + + +/* + *----------------------------------------------------------------------------- + * + * Util_SafeStrdup -- + * Helper function for strdup + * + * Results: + * Pointer to the dynamically allocated, duplicate string + * + * Side effects: + * May Panic if ran out of memory. + * + *----------------------------------------------------------------------------- + */ + +char * +UtilSafeStrdup0(const char *s) // IN: +{ + char *result; + if (s == NULL) { + return NULL; + } +#if defined(_WIN32) + if ((result = _strdup(s)) == NULL) { +#else + if ((result = strdup(s)) == NULL) { +#endif + UtilAllocationFailure0(); + } + return result; +} + + +char * +UtilSafeStrdup1(const char *s, // IN: + int bugNumber, // IN: + const char *file, // IN: + int lineno) // IN: +{ + char *result; + if (s == NULL) { + return NULL; + } +#if defined(_WIN32) + if ((result = _strdup(s)) == NULL) { +#else + if ((result = strdup(s)) == NULL) { +#endif + UtilAllocationFailure1(bugNumber, file, lineno); + } + return result; +} + + +/* + *----------------------------------------------------------------------------- + * + * Util_SafeStrndup -- + * + * Returns a string consisting of first n characters of 's' if 's' has + * length >= 'n', otherwise returns a string duplicate of 's'. + * + * Results: + * Pointer to the duplicated string. + * + * Side effects: + * May Panic if ran out of memory. + * + *----------------------------------------------------------------------------- + */ + +char * +UtilSafeStrndup0(const char *s, // IN: + size_t n) // IN: +{ + size_t size; + char *copy; + const char *null; + size_t newSize; + + if (s == NULL) { + return NULL; + } + + null = memchr(s, '\0', n); + size = null ? (size_t)(null - s) : n; + newSize = size + 1; + if (newSize < size) { // Prevent integer overflow + copy = NULL; + } else { + copy = malloc(newSize); + } + + if (copy == NULL) { + UtilAllocationFailure0(); + } + + copy[size] = '\0'; + + return (char *) memcpy(copy, s, size); +} + + +char * +UtilSafeStrndup1(const char *s, // IN: + size_t n, // IN: + int bugNumber, // IN: + const char *file, // IN: + int lineno) // IN: +{ + size_t size; + char *copy; + const char *null; + size_t newSize; + + if (s == NULL) { + return NULL; + } + + null = memchr(s, '\0', n); + size = null ? (size_t)(null - s) : n; + newSize = size + 1; + if (newSize < size) { // Prevent integer overflow + copy = NULL; + } else { + copy = malloc(newSize); + } + + if (copy == NULL) { + UtilAllocationFailure1(bugNumber, file, lineno); + } + + copy[size] = '\0'; + + return (char *) memcpy(copy, s, size); +} + + +void * +Util_Memcpy(void *dest, + const void *src, + size_t count) +{ +#if defined(__x86_64__) || defined(__i386__) + uintptr_t align = ((uintptr_t)dest | (uintptr_t)src | count); + +#if defined __GNUC__ + + #if defined(__x86_64__) + + size_t dummy0; + void *dummy1; + void *dummy2; + + if ((align & 7) == 0) { + __asm__ __volatile__("\t" + "cld" "\n\t" + "rep ; movsq" "\n" + : "=c" (dummy0), "=D" (dummy1), "=S" (dummy2) + : "0" (count >> 3), "1" (dest), "2" (src) + : "memory", "cc" + ); + return dest; + } else if ((align & 3) == 0) { + __asm__ __volatile__("\t" + "cld" "\n\t" + "rep ; movsd" "\n" + : "=c" (dummy0), "=D" (dummy1), "=S" (dummy2) + : "0" (count >> 2), "1" (dest), "2" (src) + : "memory", "cc" + ); + return dest; + } + + #elif defined(__i386__) + + size_t dummy0; + void *dummy1; + void *dummy2; + + if ((align & 3) == 0) { + __asm__ __volatile__("\t" + "cld" "\n\t" + "rep ; movsd" "\n" + : "=c" (dummy0), "=D" (dummy1), "=S" (dummy2) + : "0" (count >> 2), "1" (dest), "2" (src) + : "memory", "cc" + ); + return dest; + } + + #endif + +#elif defined _MSC_VER + + #if defined(__x86_64__) + + if ((align & 7) == 0) { + __movsq((uint64 *)dest, (uint64 *)src, count >> 3); + return dest; + } else if ((align & 3) == 0) { + __movsd((unsigned long *)dest, (unsigned long *)src, count >> 2); + return dest; + } + + #elif defined(__i386__) + + if ((((uintptr_t)dest | (uintptr_t)src | count) & 3) == 0) { + __movsd((unsigned long *)dest, (unsigned long *)src, count >> 2); + return dest; + } + + #endif + + +#endif +#endif + + memcpy(dest, src, count); + return dest; +} + + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmcheck.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmcheck.c new file mode 100644 index 0000000..8652a75 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmcheck.c @@ -0,0 +1,300 @@ +/********************************************************* + * Copyright (C) 2006-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + + +/* + * vmcheck.c -- + * + * Utility functions for discovering our virtualization status. + */ + +#include +#include + +#ifdef WINNT_DDK +# include +#endif + +#include "vmware.h" +/* + * #include "vm_version.h" + * #include "vm_tools_version.h" + */ +#define VMX_TYPE_UNSET 0 +#define VERSION_MAGIC 0x6 + +#if !defined(WINNT_DDK) +# include "hostinfo.h" +/* # include "str.h" */ +# define Str_Strcmp(s1, s2) strcmp(s1, s2) +#endif + +/* + * backdoor.h includes some files which redefine constants in ntddk.h. Ignore + * warnings about these redefinitions for WIN32 platform. + */ +#ifdef WINNT_DDK +#pragma warning (push) +// Warning: Conditional expression is constant. +#pragma warning( disable:4127 ) +#endif + +#include "backdoor.h" + +#ifdef WINNT_DDK +#pragma warning (pop) +#endif + +#include "backdoor_def.h" +#include "debug.h" + + +typedef Bool (*SafeCheckFn)(void); + +#if !defined(_WIN32) +# include "vmsignal.h" +# include "setjmp.h" + +static sigjmp_buf jmpBuf; +static Bool jmpIsSet; + + +/* + *---------------------------------------------------------------------- + * + * VmCheckSegvHandler -- + * + * Signal handler for segv. Return to the program state saved + * by a previous call to sigsetjmp, or Panic if sigsetjmp hasn't + * been called yet. This function never returns; + * + * Return Value: + * None. + * + * Side effects: + * See the manpage for sigsetjmp for details. + * + *---------------------------------------------------------------------- + */ + +static void +VmCheckSegvHandler(int clientData) // UNUSED +{ + if (jmpIsSet) { + siglongjmp(jmpBuf, 1); + } else { + Panic("Received SEGV, exiting."); + } +} +#endif + + +/* + *---------------------------------------------------------------------- + * + * VmCheckSafe -- + * + * Calls a potentially unsafe function, trapping possible exceptions. + * + * Results: + * + * Return value of the passed function, or FALSE in case of exception. + * + * Side effects: + * + * Temporarily suppresses signals / SEH exceptions + * + *---------------------------------------------------------------------- + */ + +static Bool +VmCheckSafe(SafeCheckFn checkFn) +{ + Bool result = FALSE; + + /* + * On a real host this call should cause a GP and we catch + * that and set result to FALSE. + */ + +#if defined(_WIN32) + __try { + result = checkFn(); + } __except(EXCEPTION_EXECUTE_HANDLER) { + /* no op */ + } +#else + do { + int signals[] = { + SIGILL, + SIGSEGV, + }; + struct sigaction olds[ARRAYSIZE(signals)]; + + if (Signal_SetGroupHandler(signals, olds, ARRAYSIZE(signals), + VmCheckSegvHandler) == 0) { + Warning("%s: Failed to set signal handlers.\n", __FUNCTION__); + break; + } + + if (sigsetjmp(jmpBuf, TRUE) == 0) { + jmpIsSet = TRUE; + result = checkFn(); + } else { + jmpIsSet = FALSE; + } + + if (Signal_ResetGroupHandler(signals, olds, ARRAYSIZE(signals)) == 0) { + Warning("%s: Failed to reset signal handlers.\n", __FUNCTION__); + } + } while (0); +#endif + + return result; +} + + +/* + *---------------------------------------------------------------------- + * + * VmCheck_GetVersion -- + * + * Retrieve the version of VMware that's running on the + * other side of the backdoor. + * + * Return value: + * TRUE on success + * *version contains the VMX version + * *type contains the VMX type + * FALSE on failure + * + * Side effects: + * None + * + *---------------------------------------------------------------------- + */ + +Bool +VmCheck_GetVersion(uint32 *version, // OUT + uint32 *type) // OUT +{ + Backdoor_proto bp; + + ASSERT(version); + ASSERT(type); + + /* Make sure EBX does not contain BDOOR_MAGIC */ + bp.in.size = ~BDOOR_MAGIC; + /* Make sure ECX does not contain any known VMX type */ + bp.in.cx.halfs.high = 0xFFFF; + + bp.in.cx.halfs.low = BDOOR_CMD_GETVERSION; + Backdoor(&bp); + if (bp.out.ax.word == 0xFFFFFFFF) { + /* + * No backdoor device there. This code is not executing in a VMware + * virtual machine. --hpreg + */ + return FALSE; + } + + if (bp.out.bx.word != BDOOR_MAGIC) { + return FALSE; + } + + *version = bp.out.ax.word; + + /* + * Old VMXs (workstation and express) didn't set their type. In that case, + * our special pattern will still be there. --hpreg + */ + + /* + * Need to expand this out since the toolchain's gcc doesn't like mixing + * integral types and enums in the same trinary operator. + */ + if (bp.in.cx.halfs.high == 0xFFFF) + *type = VMX_TYPE_UNSET; + else + *type = bp.out.cx.word; + + return TRUE; +} + + +/* + *---------------------------------------------------------------------- + * + * VmCheck_IsVirtualWorld -- + * + * Verify that we're running in a VM & we're version compatible with our + * environment. + * + * Return value: + * TRUE if we're in a virtual machine, FALSE otherwise. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Bool +VmCheck_IsVirtualWorld(void) +{ + uint32 version; + uint32 dummy; + +#if !defined(WINNT_DDK) + if (VmCheckSafe(Hostinfo_TouchXen)) { + Debug("%s: detected Xen.\n", __FUNCTION__); + return FALSE; + } + + if (VmCheckSafe(Hostinfo_TouchVirtualPC)) { + Debug("%s: detected Virtual PC.\n", __FUNCTION__); + return FALSE; + } + + if (!VmCheckSafe(Hostinfo_TouchBackDoor)) { + Debug("%s: backdoor not detected.\n", __FUNCTION__); + return FALSE; + } + + /* It should be safe to use the backdoor without a crash handler now. */ + VmCheck_GetVersion(&version, &dummy); +#else + /* + * The Win32 vmwvaudio driver uses this function, so keep the old, + * VMware-only check. + */ + __try { + VmCheck_GetVersion(&version, &dummy); + } __except (GetExceptionCode() == STATUS_PRIVILEGED_INSTRUCTION) { + return FALSE; + } +#endif + + if (version != VERSION_MAGIC) { + Debug("The version of this program is incompatible with your platform.\n"); + return FALSE; + } + + return TRUE; +} + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmsignal.c b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmsignal.c new file mode 100644 index 0000000..2d2c947 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/bridge/vmsignal.c @@ -0,0 +1,123 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + + +/* + * vmsignal.c -- + * + * Posix signal handling utility functions + * + */ + +#ifndef VMX86_DEVEL + +#endif + + +#include +#include +#include + + +#include "vmsignal.h" + + +/* + * Signal_SetGroupHandler -- + * + * Set a signal handler for a group of signals. + * We carefully ensure that if the handler is only used to handle the + * signals of the group, the handling of all the signals of the group is + * serialized, which means that the handler is not re-entrant. + * + * Return value: + * 1 on success + * 0 on failure (detail is displayed) + * + * Side effects: + * None + * + */ + +int +Signal_SetGroupHandler(int const *signals, // IN + struct sigaction *olds, // OUT + unsigned int nr, // IN + void (*handler)(int signal)) // IN +{ + unsigned int i; + struct sigaction new; + + new.sa_handler = handler; + if (sigemptyset(&new.sa_mask)) { + fprintf(stderr, "Unable to empty a signal set: %s.\n\n", strerror(errno)); + + return 0; + } + for (i = 0; i < nr; i++) { + if (sigaddset(&new.sa_mask, signals[i])) { + fprintf(stderr, "Unable to add a signal to a signal set: %s.\n\n", strerror(errno)); + + return 0; + } + } + new.sa_flags = 0; + + for (i = 0; i < nr; i++) { + if (sigaction(signals[i], &new, &olds[i])) { + fprintf(stderr, "Unable to modify the handler of the signal %d: %s.\n\n", signals[i], strerror(errno)); + + return 0; + } + } + + return 1; +} + + +/* + * Signal_ResetGroupHandler -- + * + * Reset the handler of each signal of a group of signals + * + * Return value: + * 1 on success + * 0 on failure (detail is displayed) + * + * Side effects: + * None + * + */ + +int +Signal_ResetGroupHandler(int const *signals, // IN + struct sigaction const *olds, // IN + unsigned int nr) // IN +{ + unsigned int i; + + for (i = 0; i < nr; i++) { + if (sigaction(signals[i], &olds[i], NULL)) { + fprintf(stderr, "Unable to reset the handler of the signal %d: %s.\n\n", signals[i], strerror(errno)); + + return 0; + } + } + + return 1; +} diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/examples/main.go b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/examples/main.go new file mode 100644 index 0000000..d37bc3d --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/examples/main.go @@ -0,0 +1,22 @@ +package main + +import ( + "fmt" + + "github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/rpcvmx" + "github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/vmcheck" +) + +func main() { + if !vmcheck.IsVirtualWorld() { + fmt.Println("not in a virtual world... :(") + return + } + + version, typ := vmcheck.GetVersion() + fmt.Println(version, typ) + + config := rpcvmx.NewConfig() + fmt.Println(config.GetString("foo", "foo")) + fmt.Println(config.GetString("bar", "foo")) +} diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor.h new file mode 100644 index 0000000..ab95db4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor.h @@ -0,0 +1,60 @@ +/********************************************************* + * Copyright (C) 1999-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoor.h -- + * + * First layer of the internal communication channel between guest + * applications and vmware + */ + +#ifndef _BACKDOOR_H_ +#define _BACKDOOR_H_ + +#include "vm_basic_types.h" +#include "vm_assert.h" + +#include "backdoor_types.h" + +void +Backdoor(Backdoor_proto *bp); // IN/OUT + +void +Backdoor_InOut(Backdoor_proto *bp); // IN/OUT + +void +Backdoor_HbOut(Backdoor_proto_hb *bp); // IN/OUT + +void +Backdoor_HbIn(Backdoor_proto_hb *bp); // IN/OUT + +#endif /* _BACKDOOR_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoorInt.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoorInt.h new file mode 100644 index 0000000..18e6f0b --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoorInt.h @@ -0,0 +1,40 @@ +/********************************************************* + * Copyright (C) 2005-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoorInt.h -- + * + * Internal function prototypes for the real backdoor work. + */ + +void BackdoorHbIn(Backdoor_proto_hb *bp); +void BackdoorHbOut(Backdoor_proto_hb *bp); diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_def.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_def.h new file mode 100644 index 0000000..046c175 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_def.h @@ -0,0 +1,261 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoor_def.h -- + * + * This contains backdoor defines that can be included from + * an assembly language file. + */ + + + +#ifndef _BACKDOOR_DEF_H_ +#define _BACKDOOR_DEF_H_ + +/* + * If you want to add a new low-level backdoor call for a guest userland + * application, please consider using the GuestRpc mechanism instead. --hpreg + */ + +#define BDOOR_MAGIC 0x564D5868 + +/* Low-bandwidth backdoor port. --hpreg */ + +#define BDOOR_PORT 0x5658 + +#define BDOOR_CMD_GETMHZ 1 +/* + * BDOOR_CMD_APMFUNCTION is used by: + * + * o The FrobOS code, which instead should either program the virtual chipset + * (like the new BIOS code does, matthias offered to implement that), or not + * use any VM-specific code (which requires that we correctly implement + * "power off on CLI HLT" for SMP VMs, boris offered to implement that) + * + * o The old BIOS code, which will soon be jettisoned + * + * --hpreg + */ +#define BDOOR_CMD_APMFUNCTION 2 /* CPL0 only. */ +#define BDOOR_CMD_GETDISKGEO 3 +#define BDOOR_CMD_GETPTRLOCATION 4 +#define BDOOR_CMD_SETPTRLOCATION 5 +#define BDOOR_CMD_GETSELLENGTH 6 +#define BDOOR_CMD_GETNEXTPIECE 7 +#define BDOOR_CMD_SETSELLENGTH 8 +#define BDOOR_CMD_SETNEXTPIECE 9 +#define BDOOR_CMD_GETVERSION 10 +#define BDOOR_CMD_GETDEVICELISTELEMENT 11 +#define BDOOR_CMD_TOGGLEDEVICE 12 +#define BDOOR_CMD_GETGUIOPTIONS 13 +#define BDOOR_CMD_SETGUIOPTIONS 14 +#define BDOOR_CMD_GETSCREENSIZE 15 +#define BDOOR_CMD_MONITOR_CONTROL 16 /* Disabled by default. */ +#define BDOOR_CMD_GETHWVERSION 17 +#define BDOOR_CMD_OSNOTFOUND 18 /* CPL0 only. */ +#define BDOOR_CMD_GETUUID 19 +#define BDOOR_CMD_GETMEMSIZE 20 +#define BDOOR_CMD_HOSTCOPY 21 /* Devel only. */ +//#define BDOOR_CMD_SERVICE_VM 22 /* Not in use. Never shipped. */ +#define BDOOR_CMD_GETTIME 23 /* Deprecated -> GETTIMEFULL. */ +#define BDOOR_CMD_STOPCATCHUP 24 +#define BDOOR_CMD_PUTCHR 25 /* Disabled by default. */ +#define BDOOR_CMD_ENABLE_MSG 26 /* Devel only. */ +#define BDOOR_CMD_GOTO_TCL 27 /* Devel only. */ +#define BDOOR_CMD_INITPCIOPROM 28 /* CPL 0 only. */ +//#define BDOOR_CMD_INT13 29 /* Not in use. */ +#define BDOOR_CMD_MESSAGE 30 +#define BDOOR_CMD_SIDT 31 +#define BDOOR_CMD_SGDT 32 +#define BDOOR_CMD_SLDT_STR 33 +#define BDOOR_CMD_ISACPIDISABLED 34 +//#define BDOOR_CMD_TOE 35 /* Not in use. */ +#define BDOOR_CMD_ISMOUSEABSOLUTE 36 +#define BDOOR_CMD_PATCH_SMBIOS_STRUCTS 37 /* CPL 0 only. */ +#define BDOOR_CMD_MAPMEM 38 /* Devel only */ +#define BDOOR_CMD_ABSPOINTER_DATA 39 +#define BDOOR_CMD_ABSPOINTER_STATUS 40 +#define BDOOR_CMD_ABSPOINTER_COMMAND 41 +//#define BDOOR_CMD_TIMER_SPONGE 42 /* Not in use. */ +#define BDOOR_CMD_PATCH_ACPI_TABLES 43 /* CPL 0 only. */ +//#define BDOOR_CMD_DEVEL_FAKEHARDWARE 44 /* Not in use. */ +#define BDOOR_CMD_GETHZ 45 +#define BDOOR_CMD_GETTIMEFULL 46 +#define BDOOR_CMD_STATELOGGER 47 /* Disabled by default. */ +#define BDOOR_CMD_CHECKFORCEBIOSSETUP 48 /* CPL 0 only. */ +#define BDOOR_CMD_LAZYTIMEREMULATION 49 /* CPL 0 only. */ +#define BDOOR_CMD_BIOSBBS 50 /* CPL 0 only. */ +//#define BDOOR_CMD_VASSERT 51 /* Not in use. */ +#define BDOOR_CMD_ISGOSDARWIN 52 +#define BDOOR_CMD_DEBUGEVENT 53 +#define BDOOR_CMD_OSNOTMACOSXSERVER 54 /* CPL 0 only. */ +#define BDOOR_CMD_GETTIMEFULL_WITH_LAG 55 +#define BDOOR_CMD_ACPI_HOTPLUG_DEVICE 56 /* Devel only. */ +#define BDOOR_CMD_ACPI_HOTPLUG_MEMORY 57 /* Devel only. */ +#define BDOOR_CMD_ACPI_HOTPLUG_CBRET 58 /* Devel only. */ +//#define BDOOR_CMD_GET_HOST_VIDEO_MODES 59 /* Not in use. */ +#define BDOOR_CMD_ACPI_HOTPLUG_CPU 60 /* Devel only. */ +//#define BDOOR_CMD_USB_HOTPLUG_MOUSE 61 /* Not in use. Never shipped. */ +#define BDOOR_CMD_XPMODE 62 /* CPL 0 only. */ +#define BDOOR_CMD_NESTING_CONTROL 63 +#define BDOOR_CMD_FIRMWARE_INIT 64 /* CPL 0 only. */ +#define BDOOR_CMD_FIRMWARE_ACPI_SERVICES 65 /* CPL 0 only. */ +# define BDOOR_CMD_FAS_GET_TABLE_SIZE 0 +# define BDOOR_CMD_FAS_GET_TABLE_DATA 1 +# define BDOOR_CMD_FAS_GET_PLATFORM_NAME 2 +# define BDOOR_CMD_FAS_GET_PCIE_OSC_MASK 3 +# define BDOOR_CMD_FAS_GET_APIC_ROUTING 4 +# define BDOOR_CMD_FAS_GET_TABLE_SKIP 5 +# define BDOOR_CMD_FAS_GET_SLEEP_ENABLES 6 +# define BDOOR_CMD_FAS_GET_HARD_RESET_ENABLE 7 +#define BDOOR_CMD_SENDPSHAREHINTS 66 +#define BDOOR_CMD_ENABLE_USB_MOUSE 67 +#define BDOOR_CMD_GET_VCPU_INFO 68 +# define BDOOR_CMD_VCPU_SLC64 0 +# define BDOOR_CMD_VCPU_SYNC_VTSCS 1 +# define BDOOR_CMD_VCPU_HV_REPLAY_OK 2 +# define BDOOR_CMD_VCPU_LEGACY_X2APIC_OK 3 +# define BDOOR_CMD_VCPU_RESERVED 31 +#define BDOOR_CMD_EFI_SERIALCON_CONFIG 69 /* CPL 0 only. */ +#define BDOOR_CMD_BUG328986 70 /* CPL 0 only. */ +#define BDOOR_CMD_FIRMWARE_ERROR 71 /* CPL 0 only. */ +# define BDOOR_CMD_FE_INSUFFICIENT_MEM 0 +# define BDOOR_CMD_FE_EXCEPTION 1 +#define BDOOR_CMD_VMK_INFO 72 +#define BDOOR_CMD_EFI_BOOT_CONFIG 73 /* CPL 0 only. */ +# define BDOOR_CMD_EBC_LEGACYBOOT_ENABLED 0 +# define BDOOR_CMD_EBC_GET_ORDER 1 +# define BDOOR_CMD_EBC_SHELL_ACTIVE 2 +# define BDOOR_CMD_EBC_GET_NETWORK_BOOT_PROTOCOL 3 +#define BDOOR_CMD_GET_HW_MODEL 74 /* CPL 0 only. */ +#define BDOOR_CMD_GET_SVGA_CAPABILITIES 75 /* CPL 0 only. */ +#define BDOOR_CMD_GET_FORCE_X2APIC 76 /* CPL 0 only */ +#define BDOOR_CMD_SET_PCI_HOLE 77 /* CPL 0 only */ +#define BDOOR_CMD_GET_PCI_HOLE 78 /* CPL 0 only */ +#define BDOOR_CMD_GET_PCI_BAR 79 /* CPL 0 only */ +#define BDOOR_CMD_SHOULD_GENERATE_SYSTEMID 80 /* CPL 0 only */ +#define BDOOR_CMD_READ_DEBUG_FILE 81 /* Devel only. */ +#define BDOOR_CMD_MAX 82 + + +/* + * IMPORTANT NOTE: When modifying the behavior of an existing backdoor command, + * you must adhere to the semantics expected by the oldest Tools who use that + * command. Specifically, do not alter the way in which the command modifies + * the registers. Otherwise backwards compatibility will suffer. + */ + +/* Processing mode for guest pshare hints (SENDPSHAREHINTS cmd) */ +#define BDOOR_PSHARE_HINTS_ASYNC 0 +#define BDOOR_PSHARE_HINTS_SYNC 1 + +#define BDOOR_PSHARE_HINTS_TYPE(ecx) (((ecx) >> 16) & 0x1) + +/* Version of backdoor pshare hints protocol */ +#define BDOOR_PSHARE_HINTS_VERSION 1 +#define BDOOR_PSHARE_HINTS_VER(ecx) (((ecx) >> 17) & 0x7f) + +/* Task applied to backdoor pshare hints */ +#define BDOOR_PSHARE_HINTS_CMD_SHARE 0 +#define BDOOR_PSHARE_HINTS_CMD_DROP 1 +#define BDOOR_PSHARE_HINTS_CMD_MAX 2 + +#define BDOOR_PSHARE_HINTS_CMD(ecx) (((ecx) >> 24) & 0xff) + +/* Nesting control operations */ + +#define NESTING_CONTROL_RESTRICT_BACKDOOR 0 +#define NESTING_CONTROL_OPEN_BACKDOOR 1 +#define NESTING_CONTROL_QUERY 2 +#define NESTING_CONTROL_MAX 2 + +/* EFI Boot Order options, nibble-sized. */ +#define EFI_BOOT_ORDER_TYPE_EFI 0x0 +#define EFI_BOOT_ORDER_TYPE_LEGACY 0x1 +#define EFI_BOOT_ORDER_TYPE_NONE 0xf + +#define BDOOR_NETWORK_BOOT_PROTOCOL_NONE 0x0 +#define BDOOR_NETWORK_BOOT_PROTOCOL_IPV4 0x1 +#define BDOOR_NETWORK_BOOT_PROTOCOL_IPV6 0x2 + +/* High-bandwidth backdoor port. --hpreg */ + +#define BDOORHB_PORT 0x5659 + +#define BDOORHB_CMD_MESSAGE 0 +#define BDOORHB_CMD_VASSERT 1 +#define BDOORHB_CMD_MAX 2 + +/* + * There is another backdoor which allows access to certain TSC-related + * values using otherwise illegal PMC indices when the pseudo_perfctr + * control flag is set. + */ + +#define BDOOR_PMC_HW_TSC 0x10000 +#define BDOOR_PMC_REAL_NS 0x10001 +#define BDOOR_PMC_APPARENT_NS 0x10002 +#define BDOOR_PMC_PSEUDO_TSC 0x10003 + +#define IS_BDOOR_PMC(index) (((index) | 3) == 0x10003) +#define BDOOR_CMD(ecx) ((ecx) & 0xffff) + +/* Sub commands for BDOOR_CMD_VMK_INFO */ +#define BDOOR_CMD_VMK_INFO_ENTRY 1 + +#ifdef VMM +/* + *---------------------------------------------------------------------- + * + * Backdoor_CmdRequiresFullyValidVCPU -- + * + * A few backdoor commands require the full VCPU to be valid + * (including GDTR, IDTR, TR and LDTR). The rest get read/write + * access to GPRs and read access to Segment registers (selectors). + * + * Result: + * True iff VECX contains a command that require the full VCPU to + * be valid. + * + *---------------------------------------------------------------------- + */ +static INLINE Bool +Backdoor_CmdRequiresFullyValidVCPU(unsigned cmd) +{ + return cmd == BDOOR_CMD_SIDT || + cmd == BDOOR_CMD_SGDT || + cmd == BDOOR_CMD_SLDT_STR; +} +#endif + +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_types.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_types.h new file mode 100644 index 0000000..3f772de --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/backdoor_types.h @@ -0,0 +1,132 @@ +/********************************************************* + * Copyright (C) 1999-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * backdoor_types.h -- + * + * Type definitions for backdoor interaction code. + */ + +#ifndef _BACKDOOR_TYPES_H_ +#define _BACKDOOR_TYPES_H_ + +#ifndef VM_I386 +#error The backdoor protocol is only supported on x86 architectures. +#endif + +/* + * These #defines are intended for defining register structs as part of + * existing named unions. If the union should encapsulate the register + * (and nothing else), use DECLARE_REG_NAMED_STRUCT defined below. + */ + +#define DECLARE_REG32_STRUCT \ + struct { \ + uint16 low; \ + uint16 high; \ + } halfs; \ + uint32 word + +#define DECLARE_REG64_STRUCT \ + DECLARE_REG32_STRUCT; \ + struct { \ + uint32 low; \ + uint32 high; \ + } words; \ + uint64 quad + +#ifndef VM_X86_64 +#define DECLARE_REG_STRUCT DECLARE_REG32_STRUCT +#else +#define DECLARE_REG_STRUCT DECLARE_REG64_STRUCT +#endif + +#define DECLARE_REG_NAMED_STRUCT(_r) \ + union { DECLARE_REG_STRUCT; } _r + +/* + * Some of the registers are expressed by semantic name, because if they were + * expressed as register structs declared above, we could only address them + * by fixed size (half-word, word, quad, etc.) instead of by varying size + * (size_t, uintptr_t). + * + * To be cleaner, these registers are expressed ONLY by semantic name, + * rather than by a union of the semantic name and a register struct. + */ +typedef union { + struct { + DECLARE_REG_NAMED_STRUCT(ax); + size_t size; /* Register bx. */ + DECLARE_REG_NAMED_STRUCT(cx); + DECLARE_REG_NAMED_STRUCT(dx); + DECLARE_REG_NAMED_STRUCT(si); + DECLARE_REG_NAMED_STRUCT(di); + } in; + struct { + DECLARE_REG_NAMED_STRUCT(ax); + DECLARE_REG_NAMED_STRUCT(bx); + DECLARE_REG_NAMED_STRUCT(cx); + DECLARE_REG_NAMED_STRUCT(dx); + DECLARE_REG_NAMED_STRUCT(si); + DECLARE_REG_NAMED_STRUCT(di); + } out; +} Backdoor_proto; + +typedef union { + struct { + DECLARE_REG_NAMED_STRUCT(ax); + DECLARE_REG_NAMED_STRUCT(bx); + size_t size; /* Register cx. */ + DECLARE_REG_NAMED_STRUCT(dx); + uintptr_t srcAddr; /* Register si. */ + uintptr_t dstAddr; /* Register di. */ + DECLARE_REG_NAMED_STRUCT(bp); + } in; + struct { + DECLARE_REG_NAMED_STRUCT(ax); + DECLARE_REG_NAMED_STRUCT(bx); + DECLARE_REG_NAMED_STRUCT(cx); + DECLARE_REG_NAMED_STRUCT(dx); + DECLARE_REG_NAMED_STRUCT(si); + DECLARE_REG_NAMED_STRUCT(di); + DECLARE_REG_NAMED_STRUCT(bp); + } out; +} Backdoor_proto_hb; + +MY_ASSERTS(BACKDOOR_STRUCT_SIZES, + ASSERT_ON_COMPILE(sizeof(Backdoor_proto) == 6 * sizeof(uintptr_t)); + ASSERT_ON_COMPILE(sizeof(Backdoor_proto_hb) == 7 * sizeof(uintptr_t)); +) + +#undef DECLARE_REG_STRUCT + +#endif /* _BACKDOOR_TYPES_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/community_source.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/community_source.h new file mode 100644 index 0000000..6f805a4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/community_source.h @@ -0,0 +1,69 @@ +/********************************************************* + * Copyright (C) 2009-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * community_source.h -- + * + * Macros for excluding source code from community. + */ + +#ifndef _COMMUNITY_SOURCE_H_ +#define _COMMUNITY_SOURCE_H_ +/* + * Convenience macro for COMMUNITY_SOURCE + */ +#undef EXCLUDE_COMMUNITY_SOURCE +#ifdef COMMUNITY_SOURCE + #define EXCLUDE_COMMUNITY_SOURCE(x) +#else + #define EXCLUDE_COMMUNITY_SOURCE(x) x +#endif + +#undef COMMUNITY_SOURCE_AMD_SECRET +#if !defined(COMMUNITY_SOURCE) || defined(AMD_SOURCE) +/* + * It's ok to include AMD_SECRET source code for non-Community Source, + * or for drops directed at AMD. + */ + #define COMMUNITY_SOURCE_AMD_SECRET +#endif + +#undef COMMUNITY_SOURCE_INTEL_SECRET +#if !defined(COMMUNITY_SOURCE) || defined(INTEL_SOURCE) +/* + * It's ok to include INTEL_SECRET source code for non-Community Source, + * or for drops directed at Intel. + */ + #define COMMUNITY_SOURCE_INTEL_SECRET +#endif + +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/cpuid_info.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/cpuid_info.h new file mode 100644 index 0000000..888c234 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/cpuid_info.h @@ -0,0 +1,88 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +#ifndef _CPUID_INFO_H +#define _CPUID_INFO_H + +#include "vm_basic_asm.h" +#include "x86cpuid_asm.h" + + +typedef struct CPUID0 { + int numEntries; + char name[16]; // 4 extra bytes to null terminate +} CPUID0; + +typedef struct CPUID1 { + uint32 version; + uint32 ebx; + uint32 ecxFeatures; + uint32 edxFeatures; +} CPUID1; + +typedef struct CPUID80 { + uint32 numEntries; + uint32 ebx; + uint32 ecx; + uint32 edx; +} CPUID80; + +typedef struct CPUID81 { + uint32 eax; + uint32 ebx; + uint32 ecxFeatures; + uint32 edxFeatures; +} CPUID81; + +typedef struct CPUIDSummary { + CPUID0 id0; + CPUID1 id1; + CPUIDRegs ida; + CPUID80 id80; + CPUID81 id81; + CPUIDRegs id88, id8a; +} CPUIDSummary; + + +/* + *---------------------------------------------------------------------- + * + * CPUIDSummary_RegsFromCpuid0 -- + * + * Fills in the given CPUIDRegs struct with the values from the CPUID0 struct. + * + * Results: + * Returns the CPUIDRegs pointer passed in. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ +static INLINE CPUIDRegs* +CPUIDSummary_RegsFromCpuid0(CPUID0* id0In, + CPUIDRegs* id0Out) +{ + id0Out->eax = id0In->numEntries; + id0Out->ebx = *(uint32 *) (id0In->name + 0); + id0Out->edx = *(uint32 *) (id0In->name + 4); + id0Out->ecx = *(uint32 *) (id0In->name + 8); + return id0Out; +} + +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/debug.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/debug.h new file mode 100644 index 0000000..8bdb727 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/debug.h @@ -0,0 +1,34 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * debug.h -- + * + * Platform specific debug routines + * + */ + + +#ifndef __DEBUG_H__ +# define __DEBUG_H__ + +# include "vm_basic_types.h" + +void Debug(char const *fmt, ...) PRINTF_DECL(1, 2); + +#endif /* __DEBUG_H__ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/dynbuf.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/dynbuf.h new file mode 100644 index 0000000..c06bd53 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/dynbuf.h @@ -0,0 +1,236 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * dynbuf.h -- + * + * Dynamic buffers + */ + +#ifndef __DYNBUF_H__ +# define __DYNBUF_H__ + +#include +#include "vm_basic_types.h" +#include "vm_assert.h" + + +typedef struct DynBuf { + char *data; + size_t size; + size_t allocated; +} DynBuf; + + +void +DynBuf_Init(DynBuf *b); // IN + +void +DynBuf_Destroy(DynBuf *b); // IN + +void * +DynBuf_AllocGet(DynBuf const *b); // IN + +void +DynBuf_Attach(DynBuf *b, // IN + size_t size, // IN + void *data); // IN + +void * +DynBuf_Detach(DynBuf *b); // IN + +Bool +DynBuf_Enlarge(DynBuf *b, // IN + size_t min_size); // IN + +Bool +DynBuf_Append(DynBuf *b, // IN + void const *data, // IN + size_t size); // IN + +Bool +DynBuf_Trim(DynBuf *b); // IN + +Bool +DynBuf_Copy(DynBuf *src, // IN + DynBuf *dest); // OUT + +void +DynBuf_SafeInternalAppend(DynBuf *b, // IN + void const *data, // IN + size_t size, // IN + char const *file, // IN + unsigned int lineno); // IN + +#define DynBuf_SafeAppend(_buf, _data, _size) \ + DynBuf_SafeInternalAppend(_buf, _data, _size, __FILE__, __LINE__) + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_Get -- + * + * Retrieve a pointer to the data contained in a dynamic buffer --hpreg + * + * Results: + * The pointer to the data + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +#if defined(SWIG) +static void * +#else +static INLINE void * +#endif +DynBuf_Get(DynBuf const *b) // IN +{ + ASSERT(b); + + return b->data; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_GetSize -- + * + * Returns the current size of the dynamic buffer --hpreg + * + * Results: + * The current size of the dynamic buffer + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +#if defined(SWIG) +static size_t +#else +static INLINE size_t +#endif +DynBuf_GetSize(DynBuf const *b) // IN +{ + ASSERT(b); + + return b->size; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_SetSize -- + * + * Set the current size of a dynamic buffer --hpreg + * + * Results: + * None + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +#if defined(SWIG) +static void +#else +static INLINE void +#endif +DynBuf_SetSize(DynBuf *b, // IN + size_t size) // IN +{ + ASSERT(b); + ASSERT(size <= b->allocated); + + b->size = size; +} + + +/* + *----------------------------------------------------------------------------- + * + * DynBuf_GetAllocatedSize -- + * + * Returns the current allocated size of the dynamic buffer --hpreg + * + * Results: + * The current allocated size of the dynamic buffer + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +#if defined(SWIG) +static size_t +#else +static INLINE size_t +#endif +DynBuf_GetAllocatedSize(DynBuf const *b) // IN +{ + ASSERT(b); + + return b->allocated; +} + + +/* + *---------------------------------------------------------------------------- + * + * DynBuf_AppendString -- + * + * Append the string to the specified DynBuf object. Basically a + * fancy strcat(). + * + * Results: + * TRUE on success + * FALSE on failure (not enough memory) + * + * + * Side effects: + * DynBuf may change its size or allocate additional memory. + * + *---------------------------------------------------------------------------- + */ + +#if defined(SWIG) +static Bool +#else +static INLINE Bool +#endif +DynBuf_AppendString(DynBuf *buf, // IN + const char *string) // IN +{ + /* + * Make sure to copy the NULL. + */ + return DynBuf_Append(buf, string, strlen(string) + 1); +} + + +#endif /* __DYNBUF_H__ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/guest_msg_def.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/guest_msg_def.h new file mode 100644 index 0000000..c0d0497 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/guest_msg_def.h @@ -0,0 +1,100 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * guest_msg_def.h -- + * + * Second layer of the internal communication channel between guest + * applications and vmware + * + */ + +#ifndef _GUEST_MSG_DEF_H_ +#define _GUEST_MSG_DEF_H_ + +/* Basic request types */ +typedef enum { + MESSAGE_TYPE_OPEN, + MESSAGE_TYPE_SENDSIZE, + MESSAGE_TYPE_SENDPAYLOAD, + MESSAGE_TYPE_RECVSIZE, + MESSAGE_TYPE_RECVPAYLOAD, + MESSAGE_TYPE_RECVSTATUS, + MESSAGE_TYPE_CLOSE, +} MessageType; + + +/* Reply statuses */ +/* The basic request succeeded */ +#define MESSAGE_STATUS_SUCCESS 0x0001 +/* vmware has a message available for its party */ +#define MESSAGE_STATUS_DORECV 0x0002 +/* The channel has been closed */ +#define MESSAGE_STATUS_CLOSED 0x0004 +/* vmware removed the message before the party fetched it */ +#define MESSAGE_STATUS_UNSENT 0x0008 +/* A checkpoint occurred */ +#define MESSAGE_STATUS_CPT 0x0010 +/* An underlying device is powering off */ +#define MESSAGE_STATUS_POWEROFF 0x0020 +/* vmware has detected a timeout on the channel */ +#define MESSAGE_STATUS_TIMEOUT 0x0040 +/* vmware supports high-bandwidth for sending and receiving the payload */ +#define MESSAGE_STATUS_HB 0x0080 + +/* + * This mask defines the status bits that the guest is allowed to set; + * we use this to mask out all other bits when receiving the status + * from the guest. Otherwise, the guest can manipulate VMX state by + * setting status bits that are only supposed to be changed by the + * VMX. See bug 45385. + */ +#define MESSAGE_STATUS_GUEST_MASK MESSAGE_STATUS_SUCCESS + +/* + * Max number of channels. + * Unfortunately this has to be public because the monitor part + * of the backdoor needs it for its trivial-case optimization. [greg] + */ +#define GUESTMSG_MAX_CHANNEL 8 + +/* Flags to open a channel. --hpreg */ +#define GUESTMSG_FLAG_COOKIE 0x80000000 +#define GUESTMSG_FLAG_ALL GUESTMSG_FLAG_COOKIE + +/* + * Maximum size of incoming message. This is to prevent denial of host service + * attacks from guest applications. + */ +#define GUESTMSG_MAX_IN_SIZE (64 * 1024) + +#endif /* _GUEST_MSG_DEF_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostType.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostType.h new file mode 100644 index 0000000..1fbf6d9 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostType.h @@ -0,0 +1,36 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * hostType.h -- + * + * Interface to host-specific information functions + * + */ + +#ifndef _HOSTTYPE_H_ +#define _HOSTTYPE_H_ + +#include "vm_basic_types.h" + +Bool HostType_OSIsVMK(void); +Bool HostType_OSIsPureVMK(void); +Bool HostType_OSIsVMK64(void); +Bool HostType_OSIsSimulator(void); + +#endif /* ifndef _HOSTTYPE_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfo.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfo.h new file mode 100644 index 0000000..73a10aa --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfo.h @@ -0,0 +1,234 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * hostinfo.h -- + * + * Interface to host-specific information functions + * + */ + +#if !defined(_HOSTINFO_H_) +#define _HOSTINFO_H_ + +#include "vm_basic_types.h" +#include "vm_basic_defs.h" +#include "x86cpuid.h" +#include "unicodeTypes.h" + +typedef enum { + HOSTINFO_PROCESS_QUERY_DEAD, // Procss is dead (does not exist) + HOSTINFO_PROCESS_QUERY_ALIVE, // Process is alive (does exist) + HOSTINFO_PROCESS_QUERY_UNKNOWN // Process existence cannot be determined +} HostinfoProcessQuery; + +HostinfoProcessQuery Hostinfo_QueryProcessExistence(int pid); + +Unicode Hostinfo_NameGet(void); /* don't free result */ +Unicode Hostinfo_HostName(void); /* free result */ + +void Hostinfo_MachineID(uint32 *hostNameHash, + uint64 *hostHardwareID); + +Bool Hostinfo_GetMemoryInfoInPages(unsigned int *minSize, + unsigned int *maxSize, + unsigned int *currentSize); +#ifdef __linux__ +Bool Hostinfo_GetSwapInfoInPages(unsigned int *totalSwap, + unsigned int *freeSwap); +#endif +Bool Hostinfo_GetRatedCpuMhz(int32 cpuNumber, + uint32 *mHz); +char *Hostinfo_GetCpuDescription(uint32 cpuNumber); +void Hostinfo_GetTimeOfDay(VmTimeType *time); +VmTimeType Hostinfo_SystemUpTime(void); +VmTimeType Hostinfo_SystemTimerNS(void); + +static INLINE VmTimeType +Hostinfo_SystemTimerUS(void) +{ + return Hostinfo_SystemTimerNS() / 1000ULL; +} + +static INLINE VmTimeType +Hostinfo_SystemTimerMS(void) +{ + return Hostinfo_SystemTimerNS() / 1000000ULL; +} + +int Hostinfo_OSVersion(unsigned int i); +int Hostinfo_GetSystemBitness(void); +const char *Hostinfo_OSVersionString(void); + +char *Hostinfo_GetOSName(void); +char *Hostinfo_GetOSGuestString(void); + +Bool Hostinfo_OSIsSMP(void); + +#if defined(_WIN32) +Bool Hostinfo_OSIsWinNT(void); +Bool Hostinfo_OSIsWow64(void); +Bool Hostinfo_TSCInvariant(void); +DWORD Hostinfo_OpenProcessBits(void); +DWORD Hostinfo_OpenThreadBits(void); +#else +void Hostinfo_ResetProcessState(const int *keepFds, + size_t numKeepFds); + +int Hostinfo_Execute(const char *path, + char * const *args, + Bool wait, + const int *keepFds, + size_t numKeepFds); + +typedef enum HostinfoDaemonizeFlags { + HOSTINFO_DAEMONIZE_DEFAULT = 0, + HOSTINFO_DAEMONIZE_NOCHDIR = (1 << 0), + HOSTINFO_DAEMONIZE_NOCLOSE = (1 << 1), + HOSTINFO_DAEMONIZE_EXIT = (1 << 2), + HOSTINFO_DAEMONIZE_LOCKPID = (1 << 3), +} HostinfoDaemonizeFlags; + +Bool Hostinfo_Daemonize(const char *path, + char * const *args, + HostinfoDaemonizeFlags flags, + const char *pidPath, + const int *keepFds, + size_t numKeepFds); +#endif + +Bool Hostinfo_NestingSupported(void); +Bool Hostinfo_VCPUInfoBackdoor(unsigned bit); +Bool Hostinfo_SLC64Supported(void); +Bool Hostinfo_SynchronizedVTSCs(void); +Bool Hostinfo_NestedHVReplaySupported(void); +Bool Hostinfo_TouchBackDoor(void); +Bool Hostinfo_TouchVirtualPC(void); +Bool Hostinfo_TouchXen(void); +char *Hostinfo_HypervisorCPUIDSig(void); + +#define HGMP_PRIVILEGE 0 +#define HGMP_NO_PRIVILEGE 1 +Unicode Hostinfo_GetModulePath(uint32 priv); +char *Hostinfo_GetLibraryPath(void *addr); + +Unicode Hostinfo_GetUser(void); +void Hostinfo_LogMemUsage(void); + + +/* + * HostInfoCpuIdInfo -- + * + * Contains cpuid information for a CPU. + */ + +typedef struct { + CpuidVendor vendor; + + uint32 version; + uint8 family; + uint8 model; + uint8 stepping; + uint8 type; + + uint32 features; + uint32 extfeatures; +} HostinfoCpuIdInfo; + + +uint32 Hostinfo_NumCPUs(void); +char *Hostinfo_GetCpuidStr(void); +Bool Hostinfo_GetCpuid(HostinfoCpuIdInfo *info); + +#if !defined(VMX86_SERVER) +Bool Hostinfo_CPUCounts(uint32 *logical, + uint32 *cores, + uint32 *pkgs); +#endif + +#if defined(_WIN32) +typedef enum { + OS_WIN95 = 1, + OS_WIN98 = 2, + OS_WINME = 3, + OS_WINNT = 4, + OS_WIN2K = 5, + OS_WINXP = 6, + OS_WIN2K3 = 7, + OS_VISTA = 8, + OS_WINSEVEN = 9, + OS_WIN8 = 10, + OS_WIN10 = 11, + OS_UNKNOWN = 99999 // last, highest value +} OS_TYPE; + +typedef enum { + OS_DETAIL_WIN95 = 1, + OS_DETAIL_WIN98 = 2, + OS_DETAIL_WINME = 3, + OS_DETAIL_WINNT = 4, + OS_DETAIL_WIN2K = 5, + OS_DETAIL_WIN2K_PRO = 6, + OS_DETAIL_WIN2K_SERV = 7, + OS_DETAIL_WIN2K_ADV_SERV = 8, + OS_DETAIL_WINXP = 9, + OS_DETAIL_WINXP_HOME = 10, + OS_DETAIL_WINXP_PRO = 11, + OS_DETAIL_WINXP_X64_PRO = 12, + OS_DETAIL_WIN2K3 = 13, + OS_DETAIL_WIN2K3_WEB = 14, + OS_DETAIL_WIN2K3_ST = 15, + OS_DETAIL_WIN2K3_EN = 16, + OS_DETAIL_WIN2K3_BUS = 17, + OS_DETAIL_VISTA = 18, + OS_DETAIL_WIN2K8 = 19, + OS_DETAIL_WINSEVEN = 20, + OS_DETAIL_WIN2K8R2 = 21, + OS_DETAIL_WIN8 = 22, + OS_DETAIL_WIN8SERVER = 23, + OS_DETAIL_WIN10 = 24, + OS_DETAIL_WIN10SERVER = 25, + OS_DETAIL_UNKNOWN = 99999 // last, highest value +} OS_DETAIL_TYPE; + +/* generic names (to protect the future) but Windows specific for now */ +OS_TYPE Hostinfo_GetOSType(void); +OS_DETAIL_TYPE Hostinfo_GetOSDetailType(void); + +Bool Hostinfo_GetPCFrequency(uint64 *pcHz); +Bool Hostinfo_GetMhzOfProcessor(int32 processorNumber, + uint32 *currentMhz, + uint32 *maxMhz); +uint64 Hostinfo_SystemIdleTime(void); +Bool Hostinfo_GetAllCpuid(CPUIDQuery *query); + +static INLINE Bool +Hostinfo_AtLeastVista(void) +{ + return (Hostinfo_GetOSType() >= OS_VISTA); +} +#endif +void Hostinfo_LogLoadAverage(void); +Bool Hostinfo_GetLoadAverage(uint32 *l); + +#ifdef __APPLE__ +size_t Hostinfo_GetKernelZoneElemSize(char const *name); +char *Hostinfo_GetHardwareModel(void); +#endif + +#endif /* ifndef _HOSTINFO_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfoInt.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfoInt.h new file mode 100644 index 0000000..edf3564 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/hostinfoInt.h @@ -0,0 +1,49 @@ +/********************************************************* + * Copyright (C) 2009-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * hostinfoInt.h -- + * + * lib/misc Hostinfo_* private declarations. + */ + +#ifndef _HOSTINFOINT_H_ +#define _HOSTINFOINT_H_ + + +#define MAX_OS_NAME_LEN 128 +#define MAX_OS_FULLNAME_LEN 512 + + +/* + * Global variables + */ + +extern volatile Bool HostinfoOSNameCacheValid; +extern char HostinfoCachedOSName[MAX_OS_NAME_LEN]; +extern char HostinfoCachedOSFullName[MAX_OS_FULLNAME_LEN]; + + +/* + * Global functions + */ + +extern Bool HostinfoOSData(void); + + +#endif // ifndef _HOSTINFOINT_H_ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/message.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/message.h new file mode 100644 index 0000000..3637e58 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/message.h @@ -0,0 +1,72 @@ +/********************************************************* + * Copyright (C) 1999-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * message.h -- + * + * Second layer of the internal communication channel between guest + * applications and vmware + */ + +#ifndef __MESSAGE_H__ +# define __MESSAGE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vm_basic_types.h" + + +typedef struct Message_Channel Message_Channel; + +Message_Channel * +Message_Open(uint32 proto); // IN + +Bool +Message_Send(Message_Channel *chan, // IN/OUT + const unsigned char *buf, // IN + size_t bufSize); // IN + +Bool +Message_Receive(Message_Channel *chan, // IN/OUT + unsigned char **buf, // OUT + size_t *bufSize); // OUT + +Bool +Message_Close(Message_Channel *chan); // IN/OUT + +#ifdef __cplusplus +} +#endif + +#endif /* __MESSAGE_H__ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/mul64.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/mul64.h new file mode 100644 index 0000000..13be403 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/mul64.h @@ -0,0 +1,143 @@ +/********************************************************* + * Copyright (C) 2003-2014 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * mul64.h + * + * Integer by fixed point multiplication, with rounding. + * + * These routines are implemented in assembly language for most + * supported platforms. This file has plain C fallback versions. + */ + +#ifndef _MUL64_H_ +#define _MUL64_H_ + +#define INCLUDE_ALLOW_USERLEVEL + +#define INCLUDE_ALLOW_MODULE +#define INCLUDE_ALLOW_VMMON +#define INCLUDE_ALLOW_VMK_MODULE +#define INCLUDE_ALLOW_VMKERNEL +#define INCLUDE_ALLOW_DISTRIBUTE +#define INCLUDE_ALLOW_VMCORE +#include "includeCheck.h" + +#include "vm_basic_asm.h" + +#ifdef MUL64_NO_ASM +/* + *----------------------------------------------------------------------------- + * + * Mul64x3264 -- + * + * Unsigned integer by fixed point multiplication, with rounding: + * result = floor(multiplicand * multiplier * 2**(-shift) + 0.5) + * + * Unsigned 64-bit integer multiplicand. + * Unsigned 32-bit fixed point multiplier, represented as + * (multiplier, shift), where shift < 64. + * + * Result: + * Unsigned 64-bit integer product. + * + *----------------------------------------------------------------------------- + */ +static INLINE uint64 +Mul64x3264(uint64 multiplicand, uint32 multiplier, uint32 shift) +{ + uint64 lo, hi, lo2, hi2; + unsigned carry; + + // ASSERT(shift >= 0 && shift < 64); + + lo = (multiplicand & 0xffffffff) * multiplier; + hi = (multiplicand >> 32) * multiplier; + + lo2 = lo + (hi << 32); + carry = lo2 < lo; + hi2 = (hi >> 32) + carry; + + if (shift == 0) { + return lo2; + } else { + return (lo2 >> shift) + (hi2 << (64 - shift)) + + ((lo2 >> (shift - 1)) & 1); + } +} + +/* + *----------------------------------------------------------------------------- + * + * Muls64x32s64 -- + * + * Signed integer by fixed point multiplication, with rounding: + * result = floor(multiplicand * multiplier * 2**(-shift) + 0.5) + * + * Signed 64-bit integer multiplicand. + * Unsigned 32-bit fixed point multiplier, represented as + * (multiplier, shift), where shift < 64. + * + * Result: + * Signed 64-bit integer product. + * + *----------------------------------------------------------------------------- + */ +static INLINE int64 +Muls64x32s64(int64 multiplicand, uint32 multiplier, uint32 shift) +{ + uint64 lo, hi, lo2, hi2; + unsigned carry; + + // ASSERT(shift >= 0 && shift < 64); + + hi = ((uint64)multiplicand >> 32) * multiplier; + if (multiplicand < 0) { + hi -= (uint64)multiplier << 32; + } + lo = ((uint64)multiplicand & 0xffffffff) * multiplier; + + lo2 = lo + (hi << 32); + carry = lo2 < lo; + hi2 = (((int64)hi >> 32) + carry); + + if (shift == 0) { + return lo2; + } else { + return (lo2 >> shift) + (hi2 << (64 - shift)) + + ((lo2 >> (shift - 1)) & 1); + } +} +#endif + +#endif // _MUL64_NOASM_H_ + diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/safetime.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/safetime.h new file mode 100644 index 0000000..85e2e2f --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/safetime.h @@ -0,0 +1,187 @@ +/********************************************************* + * Copyright (C) 2004-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * safetime.h -- + * + * This header file defines wrappers so that we use the + * 64-bit versions of the C time calls. This file is + * temporary until we switch to a newer version of + * Visual Studio that uses the 64-bit verisions by default. + * + * In Windows, the user is allowed to set the time past the + * 32-bit overflow date (in 2038), which can cause crashes + * and security problems. In Linux, the time can't be set + * to overflow, so we do nothing. + * + * NB: We do not know if one can set the time past 2038 in + * 64-bit versions of Linux, and, if so, what happens when + * one does. This requires further investigation sometime + * in the future. + * + * The stat types and functions must be defined manually, + * since they contain time_ts, and we can't use the macro + * trick, since the struct stat and the function stat have + * the same 32 bit name (but different 64 bit names). + * + */ + +#ifndef _SAFETIME_H_ +#define _SAFETIME_H_ + +#ifdef _WIN32 + +#undef FMTTIME +#define FMTTIME FMT64"d" + +#if (_MSC_VER < 1400) + +#if (defined(_STAT_DEFINED) || defined(_INC_TIME) || defined(_INC_TYPES)) +#error Use safetime.h instead of time.h, stat.h, and types.h +#endif + +#define _STAT_DEFINED + +#include +#include +#include + +#define time_t __time64_t +#define time(a) _time64(a) +#define localtime(a) _localtime64((a)) + +#define _ctime(a) _ctime64((a)) +#define ctime(a) _ctime64((a)) + +#define _ftime(a) _ftime64((a)) +#define ftime(a) _ftime64((a)) +#define _timeb __timeb64 + +#define _gmtime(a) _gmtime64((a)) +#define gmtime(a) _gmtime64((a)) + +#define _mktime(a) _mktime64((a)) +#define mktime(a) _mktime64((a)) + +#define _utime(a,b) _utime64((a),(b)) +#define utime(a,b) _utime64((a),(b)) +#define _utimbuf __utimbuf64 +#define utimbuf __utimbuf64 + +#define _wctime(a) _wctime64((a),(b)) +#define wctime(a) _wctime64((a),(b)) + +#define _futime(a,b) _futime64((a),(b)) +#define futime(a,b) _futime64((a),(b)) + +#define _wutime(a,b) _wutime64((a),(b)) +#define wutime(a,b) _wutime64((a),(b)) + +#include + +#ifdef _MSC_VER +#pragma pack(push,8) +#endif + +struct _stat { + _dev_t st_dev; + _ino_t st_ino; + unsigned short st_mode; + short st_nlink; + short st_uid; + short st_gid; + _dev_t st_rdev; + __int64 st_size; + __time64_t st_atime; + __time64_t st_mtime; + __time64_t st_ctime; + }; + +struct stat { + _dev_t st_dev; + _ino_t st_ino; + unsigned short st_mode; + short st_nlink; + short st_uid; + short st_gid; + _dev_t st_rdev; + __int64 st_size; + __time64_t st_atime; + __time64_t st_mtime; + __time64_t st_ctime; + }; + +struct __stat64 { + _dev_t st_dev; + _ino_t st_ino; + unsigned short st_mode; + short st_nlink; + short st_uid; + short st_gid; + _dev_t st_rdev; + __int64 st_size; + __time64_t st_atime; + __time64_t st_mtime; + __time64_t st_ctime; + }; + +#ifdef _MSC_VER +#pragma pack(pop) +#endif + +#include + +#define stat(a,b) _stat64((a),(struct __stat64*)(b)) +#define _stat(a,b) _stat64((a),(struct __stat64*)(b)) + +#define fstat(a,b) _fstat64((a),(struct __stat64*)(b)) +#define _fstat(a,b) _fstat64((a),(struct __stat64*)(b)) + +#define wstat(a,b) _wstat64((a),(struct __stat64*)(b)) +#define _wstat(a,b) _wstat64((a),(struct __stat64*)(b)) + +#else /* (_MSC_VER < 1400) */ + +/* + * Starting with VC80, we can pick between 32-bit and 64-bit time_t + * by defining or not defining _USE_32BIT_TIME_T. Don't define it. + */ + +#include +#include +#include +#include +#include + +/* Make sure that the headers didn't revert to 32-bit. */ +#ifdef _USE_32BIT_TIME_T +#error Refusing to use 32-bit time_t in safetime.h +#endif + +#endif /* (_MSC_VER < 1400) */ + +#else + +#include +#include +#include +#include + +#endif + +#endif diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/unicodeTypes.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/unicodeTypes.h new file mode 100644 index 0000000..ef7f655 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/unicodeTypes.h @@ -0,0 +1,485 @@ +/********************************************************* + * Copyright (C) 2007-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * unicodeTypes.h -- + * + * Types used throughout the Unicode library. + */ + +#ifndef _UNICODE_TYPES_H_ +#define _UNICODE_TYPES_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vm_basic_types.h" +#include "vm_assert.h" + +#if defined(SUPPORT_UNICODE_OPAQUE) + +/* + * To assist with finding code that hasn't been internationalized, we + * support building with an opaque Unicode type. This catches users + * passing a char * of unknown encoding to Unicode functions, and + * assigning a Unicode to a char *. + */ + +typedef struct UnicodeImpl UnicodeImpl; +typedef UnicodeImpl * Unicode; +typedef const UnicodeImpl * ConstUnicode; + +#else + +/* + * As a transitionary development tactic to prevent code churn while the + * Unicode libraries are being developed, we'll start with a simple + * implementation of Unicode as UTF-8 char *. + */ +typedef char * Unicode; +typedef const char * ConstUnicode; + +#endif + +typedef ssize_t UnicodeIndex; + +/* + * Special UnicodeIndex value returned when a string is not found. + */ +enum { + UNICODE_INDEX_NOT_FOUND = -1 +}; + + +/* + * Encodings passed to convert encoded byte strings to and from + * Unicode. + * + * Keep this enum synchronized with ICU_ENCODING_LIST in unicodeICU.cc! + */ + +typedef enum { + STRING_ENCODING_FIRST, + + /* + * Byte string encodings that support all characters in Unicode. + * + * If you don't know what to use for bytes in a new system, use + * STRING_ENCODING_UTF8. + */ + + STRING_ENCODING_UTF8 = STRING_ENCODING_FIRST, + + STRING_ENCODING_UTF16_LE, // Little-endian UTF-16. + STRING_ENCODING_UTF16_BE, // Big-endian UTF-16. + STRING_ENCODING_UTF16_XE, // UTF-16 with BOM. + + STRING_ENCODING_UTF32_LE, // Little-endian UTF-32. + STRING_ENCODING_UTF32_BE, // Big-endian UTF-32. + STRING_ENCODING_UTF32_XE, // UTF-32 with BOM. + + /* + * Legacy byte string encodings that only support a subset of Unicode. + */ + + /* + * Latin encodings + */ + + STRING_ENCODING_US_ASCII, + STRING_ENCODING_ISO_8859_1, + STRING_ENCODING_ISO_8859_2, + STRING_ENCODING_ISO_8859_3, + STRING_ENCODING_ISO_8859_4, + STRING_ENCODING_ISO_8859_5, + STRING_ENCODING_ISO_8859_6, + STRING_ENCODING_ISO_8859_7, + STRING_ENCODING_ISO_8859_8, + STRING_ENCODING_ISO_8859_9, + STRING_ENCODING_ISO_8859_10, + // ISO-8859-11 is unused. + // Oddly, there is no ISO-8859-12. + STRING_ENCODING_ISO_8859_13, + STRING_ENCODING_ISO_8859_14, + STRING_ENCODING_ISO_8859_15, + + /* + * Chinese encodings + */ + + STRING_ENCODING_GB_18030, + STRING_ENCODING_BIG_5, + STRING_ENCODING_BIG_5_HK, + STRING_ENCODING_GBK, + STRING_ENCODING_GB_2312, + STRING_ENCODING_ISO_2022_CN, + + /* + * Japanese encodings + */ + + STRING_ENCODING_SHIFT_JIS, + STRING_ENCODING_EUC_JP, + STRING_ENCODING_ISO_2022_JP, + STRING_ENCODING_ISO_2022_JP_1, + STRING_ENCODING_ISO_2022_JP_2, + + /* + * Korean encodings + */ + + STRING_ENCODING_ISO_2022_KR, + + /* + * Windows encodings + */ + + STRING_ENCODING_WINDOWS_1250, + STRING_ENCODING_WINDOWS_1251, + STRING_ENCODING_WINDOWS_1252, + STRING_ENCODING_WINDOWS_1253, + STRING_ENCODING_WINDOWS_1254, + STRING_ENCODING_WINDOWS_1255, + STRING_ENCODING_WINDOWS_1256, + STRING_ENCODING_WINDOWS_1257, + STRING_ENCODING_WINDOWS_1258, + + STRING_ENCODING_ISO_6937_2_ADD, + STRING_ENCODING_JIS_X0201, + STRING_ENCODING_JIS_ENCODING, + STRING_ENCODING_EXTENDED_UNIX_CODE_FIXED_WIDTH_FOR_JAPANESE, + STRING_ENCODING_BS_4730, + STRING_ENCODING_SEN_850200_C, + STRING_ENCODING_IT, + STRING_ENCODING_ES, + STRING_ENCODING_DIN_66003, + STRING_ENCODING_NS_4551_1, + STRING_ENCODING_NF_Z_62_010, + STRING_ENCODING_ISO_10646_UTF_1, + STRING_ENCODING_ISO_646_BASIC_1983, + STRING_ENCODING_INVARIANT, + STRING_ENCODING_ISO_646_IRV_1983, + STRING_ENCODING_NATS_SEFI, + STRING_ENCODING_NATS_SEFI_ADD, + STRING_ENCODING_NATS_DANO, + STRING_ENCODING_NATS_DANO_ADD, + STRING_ENCODING_SEN_850200_B, + STRING_ENCODING_KS_C_5601_1987, + STRING_ENCODING_JIS_C6220_1969_JP, + STRING_ENCODING_JIS_C6220_1969_RO, + STRING_ENCODING_PT, + STRING_ENCODING_GREEK7_OLD, + STRING_ENCODING_LATIN_GREEK, + STRING_ENCODING_NF_Z_62_010__1973_, + STRING_ENCODING_LATIN_GREEK_1, + STRING_ENCODING_ISO_5427, + STRING_ENCODING_JIS_C6226_1978, + STRING_ENCODING_BS_VIEWDATA, + STRING_ENCODING_INIS, + STRING_ENCODING_INIS_8, + STRING_ENCODING_INIS_CYRILLIC, + STRING_ENCODING_ISO_5427_1981, + STRING_ENCODING_ISO_5428_1980, + STRING_ENCODING_GB_1988_80, + STRING_ENCODING_GB_2312_80, + STRING_ENCODING_NS_4551_2, + STRING_ENCODING_VIDEOTEX_SUPPL, + STRING_ENCODING_PT2, + STRING_ENCODING_ES2, + STRING_ENCODING_MSZ_7795_3, + STRING_ENCODING_JIS_C6226_1983, + STRING_ENCODING_GREEK7, + STRING_ENCODING_ASMO_449, + STRING_ENCODING_ISO_IR_90, + STRING_ENCODING_JIS_C6229_1984_A, + STRING_ENCODING_JIS_C6229_1984_B, + STRING_ENCODING_JIS_C6229_1984_B_ADD, + STRING_ENCODING_JIS_C6229_1984_HAND, + STRING_ENCODING_JIS_C6229_1984_HAND_ADD, + STRING_ENCODING_JIS_C6229_1984_KANA, + STRING_ENCODING_ISO_2033_1983, + STRING_ENCODING_ANSI_X3_110_1983, + STRING_ENCODING_T_61_7BIT, + STRING_ENCODING_T_61_8BIT, + STRING_ENCODING_ECMA_CYRILLIC, + STRING_ENCODING_CSA_Z243_4_1985_1, + STRING_ENCODING_CSA_Z243_4_1985_2, + STRING_ENCODING_CSA_Z243_4_1985_GR, + STRING_ENCODING_ISO_8859_6_E, + STRING_ENCODING_ISO_8859_6_I, + STRING_ENCODING_T_101_G2, + STRING_ENCODING_ISO_8859_8_E, + STRING_ENCODING_ISO_8859_8_I, + STRING_ENCODING_CSN_369103, + STRING_ENCODING_JUS_I_B1_002, + STRING_ENCODING_IEC_P27_1, + STRING_ENCODING_JUS_I_B1_003_SERB, + STRING_ENCODING_JUS_I_B1_003_MAC, + STRING_ENCODING_GREEK_CCITT, + STRING_ENCODING_NC_NC00_10_81, + STRING_ENCODING_ISO_6937_2_25, + STRING_ENCODING_GOST_19768_74, + STRING_ENCODING_ISO_8859_SUPP, + STRING_ENCODING_ISO_10367_BOX, + STRING_ENCODING_LATIN_LAP, + STRING_ENCODING_JIS_X0212_1990, + STRING_ENCODING_DS_2089, + STRING_ENCODING_US_DK, + STRING_ENCODING_DK_US, + STRING_ENCODING_KSC5636, + STRING_ENCODING_UNICODE_1_1_UTF_7, + STRING_ENCODING_ISO_2022_CN_EXT, + STRING_ENCODING_ISO_8859_16, + STRING_ENCODING_OSD_EBCDIC_DF04_15, + STRING_ENCODING_OSD_EBCDIC_DF03_IRV, + STRING_ENCODING_OSD_EBCDIC_DF04_1, + STRING_ENCODING_ISO_11548_1, + STRING_ENCODING_KZ_1048, + STRING_ENCODING_ISO_10646_UCS_2, + STRING_ENCODING_ISO_10646_UCS_4, + STRING_ENCODING_ISO_10646_UCS_BASIC, + STRING_ENCODING_ISO_10646_UNICODE_LATIN1, + STRING_ENCODING_ISO_10646_J_1, + STRING_ENCODING_ISO_UNICODE_IBM_1261, + STRING_ENCODING_ISO_UNICODE_IBM_1268, + STRING_ENCODING_ISO_UNICODE_IBM_1276, + STRING_ENCODING_ISO_UNICODE_IBM_1264, + STRING_ENCODING_ISO_UNICODE_IBM_1265, + STRING_ENCODING_UNICODE_1_1, + STRING_ENCODING_SCSU, + STRING_ENCODING_UTF_7, + STRING_ENCODING_CESU_8, + STRING_ENCODING_BOCU_1, + STRING_ENCODING_ISO_8859_1_WINDOWS_3_0_LATIN_1, + STRING_ENCODING_ISO_8859_1_WINDOWS_3_1_LATIN_1, + STRING_ENCODING_ISO_8859_2_WINDOWS_LATIN_2, + STRING_ENCODING_ISO_8859_9_WINDOWS_LATIN_5, + STRING_ENCODING_HP_ROMAN8, + STRING_ENCODING_ADOBE_STANDARD_ENCODING, + STRING_ENCODING_VENTURA_US, + STRING_ENCODING_VENTURA_INTERNATIONAL, + STRING_ENCODING_DEC_MCS, + STRING_ENCODING_IBM_850, + STRING_ENCODING_PC8_DANISH_NORWEGIAN, + STRING_ENCODING_IBM_862, + STRING_ENCODING_PC8_TURKISH, + STRING_ENCODING_IBM_SYMBOLS, + STRING_ENCODING_IBM_THAI, + STRING_ENCODING_HP_LEGAL, + STRING_ENCODING_HP_PI_FONT, + STRING_ENCODING_HP_MATH8, + STRING_ENCODING_ADOBE_SYMBOL_ENCODING, + STRING_ENCODING_HP_DESKTOP, + STRING_ENCODING_VENTURA_MATH, + STRING_ENCODING_MICROSOFT_PUBLISHING, + STRING_ENCODING_WINDOWS_31J, + STRING_ENCODING_MACINTOSH, + STRING_ENCODING_IBM_037, + STRING_ENCODING_IBM_038, + STRING_ENCODING_IBM_273, + STRING_ENCODING_IBM_274, + STRING_ENCODING_IBM_275, + STRING_ENCODING_IBM_277, + STRING_ENCODING_IBM_278, + STRING_ENCODING_IBM_280, + STRING_ENCODING_IBM_281, + STRING_ENCODING_IBM_284, + STRING_ENCODING_IBM_285, + STRING_ENCODING_IBM_290, + STRING_ENCODING_IBM_297, + STRING_ENCODING_IBM_420, + STRING_ENCODING_IBM_423, + STRING_ENCODING_IBM_424, + STRING_ENCODING_IBM_437, + STRING_ENCODING_IBM_500, + STRING_ENCODING_IBM_851, + STRING_ENCODING_IBM_852, + STRING_ENCODING_IBM_855, + STRING_ENCODING_IBM_857, + STRING_ENCODING_IBM_860, + STRING_ENCODING_IBM_861, + STRING_ENCODING_IBM_863, + STRING_ENCODING_IBM_864, + STRING_ENCODING_IBM_865, + STRING_ENCODING_IBM_868, + STRING_ENCODING_IBM_869, + STRING_ENCODING_IBM_870, + STRING_ENCODING_IBM_871, + STRING_ENCODING_IBM_880, + STRING_ENCODING_IBM_891, + STRING_ENCODING_IBM_903, + STRING_ENCODING_IBM_904, + STRING_ENCODING_IBM_905, + STRING_ENCODING_IBM_918, + STRING_ENCODING_IBM_1026, + STRING_ENCODING_EBCDIC_AT_DE, + STRING_ENCODING_EBCDIC_AT_DE_A, + STRING_ENCODING_EBCDIC_CA_FR, + STRING_ENCODING_EBCDIC_DK_NO, + STRING_ENCODING_EBCDIC_DK_NO_A, + STRING_ENCODING_EBCDIC_FI_SE, + STRING_ENCODING_EBCDIC_FI_SE_A, + STRING_ENCODING_EBCDIC_FR, + STRING_ENCODING_EBCDIC_IT, + STRING_ENCODING_EBCDIC_PT, + STRING_ENCODING_EBCDIC_ES, + STRING_ENCODING_EBCDIC_ES_A, + STRING_ENCODING_EBCDIC_ES_S, + STRING_ENCODING_EBCDIC_UK, + STRING_ENCODING_EBCDIC_US, + STRING_ENCODING_UNKNOWN_8BIT, + STRING_ENCODING_MNEMONIC, + STRING_ENCODING_MNEM, + STRING_ENCODING_VISCII, + STRING_ENCODING_VIQR, + STRING_ENCODING_KOI8_R, + STRING_ENCODING_HZ_GB_2312, + STRING_ENCODING_IBM_866, + STRING_ENCODING_IBM_775, + STRING_ENCODING_KOI8_U, + STRING_ENCODING_IBM_00858, + STRING_ENCODING_IBM_00924, + STRING_ENCODING_IBM_01140, + STRING_ENCODING_IBM_01141, + STRING_ENCODING_IBM_01142, + STRING_ENCODING_IBM_01143, + STRING_ENCODING_IBM_01144, + STRING_ENCODING_IBM_01145, + STRING_ENCODING_IBM_01146, + STRING_ENCODING_IBM_01147, + STRING_ENCODING_IBM_01148, + STRING_ENCODING_IBM_01149, + STRING_ENCODING_IBM_1047, + STRING_ENCODING_PTCP154, + STRING_ENCODING_AMIGA_1251, + STRING_ENCODING_KOI7_SWITCHED, + STRING_ENCODING_BRF, + STRING_ENCODING_TSCII, + STRING_ENCODING_TIS_620, + STRING_ENCODING_WINDOWS_709, + STRING_ENCODING_WINDOWS_710, + STRING_ENCODING_WINDOWS_720, + STRING_ENCODING_WINDOWS_737, + STRING_ENCODING_WINDOWS_875, + STRING_ENCODING_WINDOWS_1361, + STRING_ENCODING_WINDOWS_10000, + STRING_ENCODING_WINDOWS_10001, + STRING_ENCODING_WINDOWS_10002, + STRING_ENCODING_WINDOWS_10003, + STRING_ENCODING_WINDOWS_10004, + STRING_ENCODING_WINDOWS_10005, + STRING_ENCODING_WINDOWS_10006, + STRING_ENCODING_WINDOWS_10007, + STRING_ENCODING_WINDOWS_10008, + STRING_ENCODING_WINDOWS_10010, + STRING_ENCODING_WINDOWS_10017, + STRING_ENCODING_WINDOWS_10021, + STRING_ENCODING_WINDOWS_10029, + STRING_ENCODING_WINDOWS_10079, + STRING_ENCODING_WINDOWS_10081, + STRING_ENCODING_WINDOWS_10082, + STRING_ENCODING_WINDOWS_20000, + STRING_ENCODING_WINDOWS_20001, + STRING_ENCODING_WINDOWS_20002, + STRING_ENCODING_WINDOWS_20003, + STRING_ENCODING_WINDOWS_20004, + STRING_ENCODING_WINDOWS_20005, + STRING_ENCODING_WINDOWS_20105, + STRING_ENCODING_WINDOWS_20106, + STRING_ENCODING_WINDOWS_20107, + STRING_ENCODING_WINDOWS_20108, + STRING_ENCODING_WINDOWS_20269, + STRING_ENCODING_WINDOWS_20833, + STRING_ENCODING_WINDOWS_20949, + STRING_ENCODING_WINDOWS_21025, + STRING_ENCODING_WINDOWS_21027, + STRING_ENCODING_WINDOWS_29001, + STRING_ENCODING_WINDOWS_38598, + STRING_ENCODING_WINDOWS_50221, + STRING_ENCODING_WINDOWS_50222, + STRING_ENCODING_WINDOWS_50229, + STRING_ENCODING_WINDOWS_50930, + STRING_ENCODING_WINDOWS_50931, + STRING_ENCODING_WINDOWS_50933, + STRING_ENCODING_WINDOWS_50935, + STRING_ENCODING_WINDOWS_50936, + STRING_ENCODING_WINDOWS_50937, + STRING_ENCODING_WINDOWS_50939, + STRING_ENCODING_WINDOWS_51936, + STRING_ENCODING_WINDOWS_51950, + STRING_ENCODING_WINDOWS_57002, + STRING_ENCODING_WINDOWS_57003, + STRING_ENCODING_WINDOWS_57004, + STRING_ENCODING_WINDOWS_57005, + STRING_ENCODING_WINDOWS_57006, + STRING_ENCODING_WINDOWS_57007, + STRING_ENCODING_WINDOWS_57008, + STRING_ENCODING_WINDOWS_57009, + STRING_ENCODING_WINDOWS_57010, + STRING_ENCODING_WINDOWS_57011, + STRING_ENCODING_IBM_813, + STRING_ENCODING_IBM_943_P130_1999, + STRING_ENCODING_IBM_33722, + STRING_ENCODING_WINDOWS_949, + STRING_ENCODING_IBM_1363, + STRING_ENCODING_IBM_1386, + STRING_ENCODING_IBM_1373, + STRING_ENCODING_IBM_5471, + STRING_ENCODING_IBM_874, + + // Add more encodings here. + + // Sentinel value after the last explicitly specified encoding. + STRING_ENCODING_MAX_SPECIFIED, + + /* + * The environment-specified "default" encoding for this process. + */ + + STRING_ENCODING_DEFAULT = -1, + STRING_ENCODING_UNKNOWN = -2, + + /* + * UTF-16 and UTF-32 in native byte order. + */ + + STRING_ENCODING_UTF16 = STRING_ENCODING_UTF16_LE, + STRING_ENCODING_UTF32 = STRING_ENCODING_UTF32_LE, +} StringEncoding; + + +const char *Unicode_EncodingEnumToName(StringEncoding encoding); +StringEncoding Unicode_EncodingNameToEnum(const char *encodingName); +Bool Unicode_IsEncodingValid(StringEncoding encoding); +void Unicode_Init(int argc, char ***argv, char ***envp); +void Unicode_InitEx(int argc, char ***argv, char ***envp, + const char *icuDataDir); +#if defined (_WIN32) +void Unicode_InitW(int argc, utf16_t **wargv, utf16_t **wenvp, + char ***argv, char ***envp); +#endif + +StringEncoding Unicode_GetCurrentEncoding(void); +StringEncoding Unicode_ResolveEncoding(StringEncoding encoding); + +#ifdef __cplusplus +} +#endif + +#endif // _UNICODE_TYPES_H_ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/util.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/util.h new file mode 100644 index 0000000..01fbaa8 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/util.h @@ -0,0 +1,694 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/* + * util.h -- + * + * misc util functions + */ + +#ifndef UTIL_H +#define UTIL_H + +#include +#include +#ifndef VMKBOOT +#include +#endif + +#ifdef _WIN32 + #ifdef USERLEVEL + #include /* Needed for MBCS string functions */ + #include /* for definition of HANDLE */ + #endif +#else + #include + #include "errno.h" +#endif +#include "vm_assert.h" +#include "vm_basic_defs.h" +#include "unicodeTypes.h" + + +/* + * Define the Util_ThreadID type, and assorted standard bits. + */ +#if defined(_WIN32) + typedef DWORD Util_ThreadID; +#else + #include + #if defined(__APPLE__) || defined(__FreeBSD__) + #include + typedef pthread_t Util_ThreadID; + #else // Linux et al + typedef pid_t Util_ThreadID; + #endif +#endif + +uint32 CRC_Compute(const uint8 *buf, int len); +uint32 Util_Checksum32(const uint32 *buf, int len); +uint32 Util_Checksum(const uint8 *buf, int len); +uint32 Util_Checksumv(void *iov, int numEntries); +uint32 Util_HashString(const char *str); +Unicode Util_ExpandString(ConstUnicode fileName); +void Util_ExitThread(int); +NORETURN void Util_ExitProcessAbruptly(int); +int Util_HasAdminPriv(void); +#if defined _WIN32 && defined USERLEVEL +int Util_TokenHasAdminPriv(HANDLE token); +int Util_TokenHasInteractPriv(HANDLE token); +#endif +Bool Util_Data2Buffer(char *buf, size_t bufSize, const void *data0, + size_t dataSize); +char *Util_GetCanonicalPath(const char *path); +#ifdef _WIN32 +char *Util_CompatGetCanonicalPath(const char *path); +char *Util_GetCanonicalPathForHash(const char *path); +char *Util_CompatGetLowerCaseCanonicalPath(const char* path); +#endif +int Util_BumpNoFds(uint32 *cur, uint32 *wanted); +Bool Util_CanonicalPathsIdentical(const char *path1, const char *path2); +Bool Util_IsAbsolutePath(const char *path); +unsigned Util_GetPrime(unsigned n0); +Util_ThreadID Util_GetCurrentThreadId(void); + +char *Util_DeriveFileName(const char *source, + const char *name, + const char *ext); + +char *Util_CombineStrings(char **sources, int count); +char **Util_SeparateStrings(char *source, int *count); + +typedef struct UtilSingleUseResource UtilSingleUseResource; +UtilSingleUseResource *Util_SingleUseAcquire(const char *name); +void Util_SingleUseRelease(UtilSingleUseResource *res); + +#ifndef _WIN32 +Bool Util_IPv4AddrValid(const char *addr); +Bool Util_IPv6AddrValid(const char *addr); +Bool Util_IPAddrValid(const char *addr); +#endif + +#if defined(__linux__) || defined(__FreeBSD__) || defined(sun) +Bool Util_GetProcessName(pid_t pid, char *bufOut, size_t bufOutSize); +#endif + +#if defined __linux__ && !defined VMX86_SERVER +Bool Util_IsPhysicalSSD(const char* device); +#endif + +// backtrace functions and utilities + +#define UTIL_BACKTRACE_LINE_LEN (511) +typedef void (*Util_OutputFunc)(void *data, const char *fmt, ...); + +void Util_Backtrace(int bugNr); +void Util_BacktraceFromPointer(uintptr_t *basePtr); +void Util_BacktraceFromPointerWithFunc(uintptr_t *basePtr, + Util_OutputFunc outFunc, + void *outFuncData); +void Util_BacktraceWithFunc(int bugNr, + Util_OutputFunc outFunc, + void *outFuncData); + +void Util_BacktraceToBuffer(uintptr_t *basePtr, + uintptr_t *buffer, int len); + +// sleep functions + +void Util_Usleep(long usec); +void Util_Sleep(unsigned int sec); + +int Util_CompareDotted(const char *s1, const char *s2); + +/* + * This enum defines how Util_GetOpt should handle non-option arguments: + * + * UTIL_NONOPT_PERMUTE: Permute argv so that all non-options are at the end. + * UTIL_NONOPT_STOP: Stop when first non-option argument is seen. + * UTIL_NONOPT_ALL: Return each non-option argument as if it were + * an option with character code 1. + */ +typedef enum { UTIL_NONOPT_PERMUTE, UTIL_NONOPT_STOP, UTIL_NONOPT_ALL } Util_NonOptMode; +struct option; +int Util_GetOpt(int argc, char * const *argv, const struct option *opts, + Util_NonOptMode mode); + + +#if defined(VMX86_STATS) +Bool Util_QueryCStResidency(uint32 *numCpus, uint32 *numCStates, + uint64 **transitns, uint64 **residency, + uint64 **transTime, uint64 **residTime); +#endif + +/* + * In util_shared.h + */ +#define UTIL_FASTRAND_SEED_MAX (0x7fffffff) +Bool Util_Throttle(uint32 count); +uint32 Util_FastRand(uint32 seed); + + +// Not thread safe! +void Util_OverrideHomeDir(const char *path); + + +/* + *----------------------------------------------------------------------------- + * + * Util_ValidateBytes -- + * + * Check that memory is filled with the specified value. + * + * Results: + * NULL No error + * !NULL First address that doesn't have the proper value + * + * Side effects: + * None. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void * +Util_ValidateBytes(const void *ptr, // IN: ptr to check + size_t size, // IN: size of ptr + uint8 byteValue) // IN: memory must be filled with this +{ + uint8 *p; + uint8 *end; + uint64 bigValue; + + ASSERT(ptr); + + if (size == 0) { + return NULL; + } + + p = (uint8 *) ptr; + end = p + size; + + /* Compare bytes until a "nice" boundary is achieved. */ + while ((uintptr_t) p % sizeof bigValue) { + if (*p != byteValue) { + return p; + } + + p++; + + if (p == end) { + return NULL; + } + } + + /* Compare using a "nice sized" chunk for a long as possible. */ + memset(&bigValue, (int) byteValue, sizeof bigValue); + + while (p + sizeof bigValue <= end) { + if (*((uint64 *) p) != bigValue) { + /* That's not right... let the loop below report the exact address. */ + break; + } + + size -= sizeof bigValue; + p += sizeof bigValue; + } + + /* Handle any trailing bytes. */ + while (p < end) { + if (*p != byteValue) { + return p; + } + + p++; + } + + return NULL; +} + + +/* + *---------------------------------------------------------------------- + * + * Util_BufferIsEmpty -- + * + * Determine if the specified buffer of 'len' bytes starting at 'base' + * is empty (i.e. full of zeroes). + * + * Results: + * TRUE Yes + * FALSE No + * + * Side effects: + * None + * + *---------------------------------------------------------------------- + */ + +static INLINE Bool +Util_BufferIsEmpty(void const *base, // IN: + size_t len) // IN: +{ + return Util_ValidateBytes(base, len, '\0') == NULL; +} + + +Bool Util_MakeSureDirExistsAndAccessible(char const *path, + unsigned int mode); + +#if _WIN32 +# define DIRSEPS "\\" +# define DIRSEPS_W L"\\" +# define DIRSEPC '\\' +# define DIRSEPC_W L'\\' +# define VALID_DIRSEPS "\\/" +# define VALID_DIRSEPS_W L"\\/" +# define CUR_DIRS_W L"." +# define CUR_DIRC_W L'.' +#else +# define DIRSEPS "/" +# define DIRSEPC '/' +# define VALID_DIRSEPS DIRSEPS +#endif + +#define CURR_DIRS "." +#define CURR_DIRC '.' + +/* + *----------------------------------------------------------------------- + * + * Util_Safe[Malloc, Realloc, Calloc, Strdup] and + * Util_Safe[Malloc, Realloc, Calloc, Strdup]Bug -- + * + * These functions work just like the standard C library functions + * (except Util_SafeStrdup[,Bug]() accept NULL, see below), + * but will not fail. Instead they Panic(), printing the file and + * line number of the caller, if the underlying library function + * fails. The Util_SafeFnBug functions print bugNumber in the + * Panic() message. + * + * These functions should only be used when there is no way to + * gracefully recover from the error condition. + * + * The internal versions of these functions expect a bug number + * as the first argument. If that bug number is something other + * than -1, the panic message will include the bug number. + * + * Since Util_SafeStrdup[,Bug]() do not need to return NULL + * on error, they have been extended to accept the null pointer + * (and return it). The competing view is that they should + * panic on NULL. This is a convenience vs. strictness argument. + * Convenience wins. -- edward + * + * Results: + * The freshly allocated memory. + * + * Side effects: + * Panic() if the library function fails. + * + *-------------------------------------------------------------------------- + */ + +void *UtilSafeMalloc0(size_t size); +void *UtilSafeMalloc1(size_t size, + int bugNumber, const char *file, int lineno); + +void *UtilSafeRealloc0(void *ptr, size_t size); +void *UtilSafeRealloc1(void *ptr, size_t size, + int bugNumber, const char *file, int lineno); + +void *UtilSafeCalloc0(size_t nmemb, size_t size); +void *UtilSafeCalloc1(size_t nmemb, size_t size, + int bugNumber, const char *file, int lineno); + +char *UtilSafeStrdup0(const char *s); +char *UtilSafeStrdup1(const char *s, + int bugNumber, const char *file, int lineno); + +char *UtilSafeStrndup0(const char *s, size_t n); +char *UtilSafeStrndup1(const char *s, size_t n, + int bugNumber, const char *file, int lineno); + +/* + * Debug builds carry extra arguments into the allocation functions for + * better error reporting. Non-debug builds don't pay this extra overhead. + */ +#ifdef VMX86_DEBUG + +#define Util_SafeMalloc(_size) \ + UtilSafeMalloc1((_size), -1, __FILE__, __LINE__) + +#define Util_SafeMallocBug(_bugNr, _size) \ + UtilSafeMalloc1((_size),(_bugNr), __FILE__, __LINE__) + +#define Util_SafeRealloc(_ptr, _size) \ + UtilSafeRealloc1((_ptr), (_size), -1, __FILE__, __LINE__) + +#define Util_SafeReallocBug(_bugNr, _ptr, _size) \ + UtilSafeRealloc1((_ptr), (_size), (_bugNr), __FILE__, __LINE__) + +#define Util_SafeCalloc(_nmemb, _size) \ + UtilSafeCalloc1((_nmemb), (_size), -1, __FILE__, __LINE__) + +#define Util_SafeCallocBug(_bugNr, _nmemb, _size) \ + UtilSafeCalloc1((_nmemb), (_size), (_bugNr), __FILE__, __LINE__) + +#define Util_SafeStrndup(_str, _size) \ + UtilSafeStrndup1((_str), (_size), -1, __FILE__, __LINE__) + +#define Util_SafeStrndupBug(_bugNr, _str, _size) \ + UtilSafeStrndup1((_str), (_size), (_bugNr), __FILE__, __LINE__) + +#define Util_SafeStrdup(_str) \ + UtilSafeStrdup1((_str), -1, __FILE__, __LINE__) + +#define Util_SafeStrdupBug(_bugNr, _str) \ + UtilSafeStrdup1((_str), (_bugNr), __FILE__, __LINE__) + +#else /* VMX86_DEBUG */ + +#define Util_SafeMalloc(_size) \ + UtilSafeMalloc0((_size)) + +#define Util_SafeMallocBug(_bugNr, _size) \ + UtilSafeMalloc0((_size)) + +#define Util_SafeRealloc(_ptr, _size) \ + UtilSafeRealloc0((_ptr), (_size)) + +#define Util_SafeReallocBug(_ptr, _size) \ + UtilSafeRealloc0((_ptr), (_size)) + +#define Util_SafeCalloc(_nmemb, _size) \ + UtilSafeCalloc0((_nmemb), (_size)) + +#define Util_SafeCallocBug(_bugNr, _nmemb, _size) \ + UtilSafeCalloc0((_nmemb), (_size)) + +#define Util_SafeStrndup(_str, _size) \ + UtilSafeStrndup0((_str), (_size)) + +#define Util_SafeStrndupBug(_bugNr, _str, _size) \ + UtilSafeStrndup0((_str), (_size)) + +#define Util_SafeStrdup(_str) \ + UtilSafeStrdup0((_str)) + +#define Util_SafeStrdupBug(_bugNr, _str) \ + UtilSafeStrdup0((_str)) + +#endif /* VMX86_DEBUG */ + + +void *Util_Memcpy(void *dest, const void *src, size_t count); + + +/* + *----------------------------------------------------------------------------- + * + * Util_Zero -- + * + * Zeros out bufSize bytes of buf. NULL is legal. + * + * Results: + * None. + * + * Side effects: + * See above. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_Zero(void *buf, // OUT + size_t bufSize) // IN +{ + if (buf != NULL) { +#if defined _WIN32 && defined USERLEVEL + /* + * Simple memset calls might be optimized out. See CERT advisory + * MSC06-C. + */ + SecureZeroMemory(buf, bufSize); +#else + memset(buf, 0, bufSize); +#if !defined _WIN32 + /* + * Memset calls before free might be optimized out. See PR1248269. + */ + __asm__ __volatile__("" : : "r"(&buf) : "memory"); +#endif +#endif + } +} + + +/* + *----------------------------------------------------------------------------- + * + * Util_ZeroString -- + * + * Zeros out a NULL-terminated string. NULL is legal. + * + * Results: + * None. + * + * Side effects: + * See above. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_ZeroString(char *str) // IN/OUT +{ + if (str != NULL) { + Util_Zero(str, strlen(str)); + } +} + + +#ifndef VMKBOOT +/* + *----------------------------------------------------------------------------- + * + * Util_ZeroFree -- + * + * Zeros out bufSize bytes of buf, and then frees it. NULL is + * legal. + * + * Results: + * None. + * + * Side effects: + * buf is zeroed, and then free() is called on it. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_ZeroFree(void *buf, // OUT + size_t bufSize) // IN +{ + if (buf != NULL) { + Util_Zero(buf, bufSize); + free(buf); + } +} + + +/* + *----------------------------------------------------------------------------- + * + * Util_ZeroFreeString -- + * + * Zeros out a NULL-terminated string, and then frees it. NULL is + * legal. + * + * Results: + * None. + * + * Side effects: + * str is zeroed, and then free() is called on it. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_ZeroFreeString(char *str) // IN +{ + if (str != NULL) { + Util_ZeroString(str); + free(str); + } +} + + +#ifdef _WIN32 +/* + *----------------------------------------------------------------------------- + * + * Util_ZeroFreeStringW -- + * + * Zeros out a NUL-terminated wide-character string, and then frees it. + * NULL is legal. + * + * Results: + * None. + * + * Side effects: + * str is zeroed, and then free() is called on it. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_ZeroFreeStringW(wchar_t *str) // IN +{ + if (str != NULL) { + Util_Zero(str, wcslen(str) * sizeof *str); + free(str); + } +} +#endif // _WIN32 + + +/* + *----------------------------------------------------------------------------- + * + * Util_FreeList -- + * Util_FreeStringList -- + * + * Free a list (actually a vector) of allocated objects. + * The list (vector) itself is also freed. + * + * The list either has a specified length or is + * argv-style NULL terminated (if length is negative). + * + * The list can be NULL, in which case no operation is performed. + * + * Results: + * None + * + * Side effects: + * errno or Windows last error is preserved. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void +Util_FreeList(void **list, // IN/OUT: the list to free + ssize_t length) // IN: the length +{ + if (list == NULL) { + ASSERT(length <= 0); + return; + } + + if (length >= 0) { + ssize_t i; + + for (i = 0; i < length; i++) { + free(list[i]); + DEBUG_ONLY(list[i] = NULL); + } + } else { + void **s; + + for (s = list; *s != NULL; s++) { + free(*s); + DEBUG_ONLY(*s = NULL); + } + } + free(list); +} + +static INLINE void +Util_FreeStringList(char **list, // IN/OUT: the list to free + ssize_t length) // IN: the length +{ + Util_FreeList((void **) list, length); +} +#endif + +#ifndef _WIN32 +/* + *----------------------------------------------------------------------------- + * + * Util_IsFileDescriptorOpen -- + * + * Check if given file descriptor is open. + * + * Results: + * TRUE if fd is open. + * + * Side effects: + * Clobbers errno. + * + *----------------------------------------------------------------------------- + */ + +static INLINE Bool +Util_IsFileDescriptorOpen(int fd) // IN +{ + return (lseek(fd, 0L, SEEK_CUR) == -1) ? errno != EBADF : TRUE; +} +#endif /* !_WIN32 */ + + +/* + *----------------------------------------------------------------------------- + * + * Util_Memcpy32 -- + * + * Special purpose version of memcpy that requires nbytes be a + * multiple of 4. This assumption lets us have a very small, + * inlineable implementation. + * + * Results: + * dst + * + * Side effects: + * See above. + * + *----------------------------------------------------------------------------- + */ + +static INLINE void * +Util_Memcpy32(void *dst, const void *src, size_t nbytes) +{ + ASSERT((nbytes % 4) == 0); +#if defined __GNUC__ && (defined(__i386__) || defined(__x86_64__)) + do { + int dummy0, dummy1, dummy2; + __asm__ __volatile__( + "cld \n\t" + "rep ; movsl" "\n\t" + : "=&c" (dummy0), "=&D" (dummy1), "=&S" (dummy2) + : "0" (nbytes / 4), "1" ((long) dst), "2" ((long) src) + : "memory", "cc" + ); + return dst; + } while (0); +#else + return memcpy(dst, src, nbytes); +#endif +} + + +#endif /* UTIL_H */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_assert.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_assert.h new file mode 100644 index 0000000..2b5a200 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_assert.h @@ -0,0 +1,359 @@ +/********************************************************* + * Copyright (C) 1998-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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 REGENTS 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 REGENTS 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. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * vm_assert.h -- + * + * The basic assertion facility for all VMware code. + * + * For proper use, see bora/doc/assert and + * http://vmweb.vmware.com/~mts/WebSite/guide/programming/asserts.html. + */ + +#ifndef _VM_ASSERT_H_ +#define _VM_ASSERT_H_ + +// XXX not necessary except some places include vm_assert.h improperly +#include "vm_basic_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Some bits of vmcore are used in VMKernel code and cannot have + * the VMKERNEL define due to other header dependencies. + */ +#if defined(VMKERNEL) && !defined(VMKPANIC) +#define VMKPANIC 1 +#endif + +/* + * Internal macros, functions, and strings + * + * The monitor wants to save space at call sites, so it has specialized + * functions for each situation. User level wants to save on implementation + * so it uses generic functions. + */ + +#if !defined VMM || defined MONITOR_APP // { + +#if defined VMKPANIC + +#include "vmk_assert.h" + +#else /* !VMKPANIC */ +#define _ASSERT_PANIC(name) \ + Panic(_##name##Fmt "\n", __FILE__, __LINE__) +#define _ASSERT_PANIC_BUG(bug, name) \ + Panic(_##name##Fmt " bugNr=%d\n", __FILE__, __LINE__, bug) +#define _ASSERT_PANIC_NORETURN(name) \ + Panic(_##name##Fmt "\n", __FILE__, __LINE__) +#define _ASSERT_PANIC_BUG_NORETURN(bug, name) \ + Panic(_##name##Fmt " bugNr=%d\n", __FILE__, __LINE__, bug) +#endif /* VMKPANIC */ + +#endif // } + + +// These strings don't have newline so that a bug can be tacked on. +#define _AssertPanicFmt "PANIC %s:%d" +#define _AssertAssertFmt "ASSERT %s:%d" +#define _AssertVerifyFmt "VERIFY %s:%d" +#define _AssertNotImplementedFmt "NOT_IMPLEMENTED %s:%d" +#define _AssertNotReachedFmt "NOT_REACHED %s:%d" +#define _AssertMemAllocFmt "MEM_ALLOC %s:%d" +#define _AssertNotTestedFmt "NOT_TESTED %s:%d" + + +/* + * Panic and log functions + */ + +void Log(const char *fmt, ...) PRINTF_DECL(1, 2); +void Warning(const char *fmt, ...) PRINTF_DECL(1, 2); +#if defined VMKPANIC +void Panic_SaveRegs(void); + +#ifdef VMX86_DEBUG +void Panic_NoSave(const char *fmt, ...) PRINTF_DECL(1, 2); +#else +NORETURN void Panic_NoSave(const char *fmt, ...) PRINTF_DECL(1, 2); +#endif + +NORETURN void Panic_NoSaveNoReturn(const char *fmt, ...) PRINTF_DECL(1, 2); + +#define Panic(fmt...) do { \ + Panic_SaveRegs(); \ + Panic_NoSave(fmt); \ +} while(0) + +#define Panic_NoReturn(fmt...) do { \ + Panic_SaveRegs(); \ + Panic_NoSaveNoReturn(fmt); \ +} while(0) + +#else +NORETURN void Panic(const char *fmt, ...) PRINTF_DECL(1, 2); +#endif + +void LogThrottled(uint32 *count, const char *fmt, ...) PRINTF_DECL(2, 3); +void WarningThrottled(uint32 *count, const char *fmt, ...) PRINTF_DECL(2, 3); + + +#ifndef ASSERT_IFNOT + /* + * PR 271512: When compiling with gcc, catch assignments inside an ASSERT. + * + * 'UNLIKELY' is defined with __builtin_expect, which does not warn when + * passed an assignment (gcc bug 36050). To get around this, we put 'cond' + * in an 'if' statement and make sure it never gets executed by putting + * that inside of 'if (0)'. We use gcc's statement expression syntax to + * make ASSERT an expression because some code uses it that way. + * + * Since statement expression syntax is a gcc extension and since it's + * not clear if this is a problem with other compilers, the ASSERT + * definition was not changed for them. Using a bare 'cond' with the + * ternary operator may provide a solution. + */ + + #ifdef __GNUC__ + #define ASSERT_IFNOT(cond, panic) \ + ({if (UNLIKELY(!(cond))) { panic; if (0) { if (cond) {;}}} (void)0;}) + #else + #define ASSERT_IFNOT(cond, panic) \ + (UNLIKELY(!(cond)) ? (panic) : (void)0) + #endif +#endif + + +/* + * Assert, panic, and log macros + * + * Some of these are redefined below undef !VMX86_DEBUG. + * ASSERT() is special cased because of interaction with Windows DDK. + */ + +#if defined VMX86_DEBUG +#undef ASSERT +#define ASSERT(cond) ASSERT_IFNOT(cond, _ASSERT_PANIC(AssertAssert)) +#define ASSERT_BUG(bug, cond) \ + ASSERT_IFNOT(cond, _ASSERT_PANIC_BUG(bug, AssertAssert)) +#endif + +#undef VERIFY +#define VERIFY(cond) \ + ASSERT_IFNOT(cond, _ASSERT_PANIC_NORETURN(AssertVerify)) +#define VERIFY_BUG(bug, cond) \ + ASSERT_IFNOT(cond, _ASSERT_PANIC_BUG_NORETURN(bug, AssertVerify)) + +#define PANIC() _ASSERT_PANIC(AssertPanic) +#define PANIC_BUG(bug) _ASSERT_PANIC_BUG(bug, AssertPanic) + +#define ASSERT_NOT_IMPLEMENTED(cond) \ + ASSERT_IFNOT(cond, NOT_IMPLEMENTED()) +#define ASSERT_NOT_IMPLEMENTED_BUG(bug, cond) \ + ASSERT_IFNOT(cond, NOT_IMPLEMENTED_BUG(bug)) + +#if defined VMKPANIC || defined VMM +#define NOT_IMPLEMENTED() _ASSERT_PANIC_NORETURN(AssertNotImplemented) +#else +#define NOT_IMPLEMENTED() _ASSERT_PANIC(AssertNotImplemented) +#endif + +#if defined VMM +#define NOT_IMPLEMENTED_BUG(bug) \ + _ASSERT_PANIC_BUG_NORETURN(bug, AssertNotImplemented) +#else +#define NOT_IMPLEMENTED_BUG(bug) _ASSERT_PANIC_BUG(bug, AssertNotImplemented) +#endif + +#if defined VMKPANIC || defined VMM +#define NOT_REACHED() _ASSERT_PANIC_NORETURN(AssertNotReached) +#else +#define NOT_REACHED() _ASSERT_PANIC(AssertNotReached) +#endif + +#define ASSERT_MEM_ALLOC(cond) \ + ASSERT_IFNOT(cond, _ASSERT_PANIC(AssertMemAlloc)) + +#ifdef VMX86_DEVEL +#define ASSERT_DEVEL(cond) ASSERT(cond) +#define NOT_TESTED() Warning(_AssertNotTestedFmt "\n", __FILE__, __LINE__) +#else +#define ASSERT_DEVEL(cond) ((void)0) +#define NOT_TESTED() Log(_AssertNotTestedFmt "\n", __FILE__, __LINE__) +#endif + +#define ASSERT_NO_INTERRUPTS() ASSERT(!INTERRUPTS_ENABLED()) +#define ASSERT_HAS_INTERRUPTS() ASSERT(INTERRUPTS_ENABLED()) + +#define ASSERT_NOT_TESTED(cond) (UNLIKELY(!(cond)) ? NOT_TESTED() : (void)0) +#define NOT_TESTED_ONCE() DO_ONCE(NOT_TESTED()) + +#define NOT_TESTED_1024() \ + do { \ + static uint16 count = 0; \ + if (UNLIKELY(count == 0)) { NOT_TESTED(); } \ + count = (count + 1) & 1023; \ + } while (0) + +#define LOG_ONCE(_s) DO_ONCE(Log _s) + + +/* + * Redefine macros that are only in debug versions + */ + +#if !defined VMX86_DEBUG // { + +#undef ASSERT +#define ASSERT(cond) ((void)0) +#define ASSERT_BUG(bug, cond) ((void)0) + +/* + * Expand NOT_REACHED() as appropriate for each situation. + * + * Mainly, we want the compiler to infer the same control-flow + * information as it would from Panic(). Otherwise, different + * compilation options will lead to different control-flow-derived + * errors, causing some make targets to fail while others succeed. + * + * VC++ has the __assume() built-in function which we don't trust + * (see bug 43485); gcc has no such construct; we just panic in + * userlevel code. The monitor doesn't want to pay the size penalty + * (measured at 212 bytes for the release vmm for a minimal infinite + * loop; panic would cost even more) so it does without and lives + * with the inconsistency. + */ + +#if defined VMKPANIC || defined VMM +#undef NOT_REACHED +#if defined __GNUC__ && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 5) +#define NOT_REACHED() (__builtin_unreachable()) +#else +#define NOT_REACHED() ((void)0) +#endif +#else +// keep debug definition +#endif + +#undef LOG_UNEXPECTED +#define LOG_UNEXPECTED(bug) ((void)0) + +#undef ASSERT_NOT_TESTED +#define ASSERT_NOT_TESTED(cond) ((void)0) +#undef NOT_TESTED +#define NOT_TESTED() ((void)0) +#undef NOT_TESTED_ONCE +#define NOT_TESTED_ONCE() ((void)0) +#undef NOT_TESTED_1024 +#define NOT_TESTED_1024() ((void)0) + +#endif // !VMX86_DEBUG } + + +/* + * Compile-time assertions. + * + * ASSERT_ON_COMPILE does not use the common + * switch (0) { case 0: case (e): ; } trick because some compilers (e.g. MSVC) + * generate code for it. + * + * The implementation uses both enum and typedef because the typedef alone is + * insufficient; gcc allows arrays to be declared with non-constant expressions + * (even in typedefs, where it makes no sense). + * + * NOTE: if GCC ever changes so that it ignores unused types altogether, this + * assert might not fire! We explicitly mark it as unused because GCC 4.8+ + * uses -Wunused-local-typedefs as part of -Wall, which means the typedef will + * generate a warning. + */ + +#define ASSERT_ON_COMPILE(e) \ + do { \ + enum { AssertOnCompileMisused = ((e) ? 1 : -1) }; \ + UNUSED_TYPE(typedef char AssertOnCompileFailed[AssertOnCompileMisused]); \ + } while (0) + + +/* + * To put an ASSERT_ON_COMPILE() outside a function, wrap it + * in MY_ASSERTS(). The first parameter must be unique in + * each .c file where it appears. For example, + * + * MY_ASSERTS(FS3_INT, + * ASSERT_ON_COMPILE(sizeof(FS3_DiskLock) == 128); + * ASSERT_ON_COMPILE(sizeof(FS3_DiskLockReserved) == DISK_BLOCK_SIZE); + * ASSERT_ON_COMPILE(sizeof(FS3_DiskBlock) == DISK_BLOCK_SIZE); + * ASSERT_ON_COMPILE(sizeof(Hardware_DMIUUID) == 16); + * ) + * + * Caution: ASSERT() within MY_ASSERTS() is silently ignored. + * The same goes for anything else not evaluated at compile time. + */ + +#define MY_ASSERTS(name, assertions) \ + static INLINE void name(void) { \ + assertions \ + } + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* ifndef _VM_ASSERT_H_ */ diff --git a/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_basic_asm.h b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_basic_asm.h new file mode 100644 index 0000000..c0b66e6 --- /dev/null +++ b/Godeps/_workspace/src/github.com/sigma/vmw-guestinfo/include/vm_basic_asm.h @@ -0,0 +1,1400 @@ +/********************************************************* + * Copyright (C) 2003-2015 VMware, Inc. All rights reserved. + * + * This program 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 version 2.1 and no 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 Lesser GNU General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + *********************************************************/ + +/********************************************************* + * The contents of this file are subject to the terms of the Common + * Development and Distribution License (the "License") version 1.0 + * and no later version. You may not use this file except in + * compliance with the License. + * + * You can obtain a copy of the License at + * http://www.opensource.org/licenses/cddl1.php + * + * See the License for the specific language governing permissions + * and limitations under the License. + * + *********************************************************/ + +/* + * vm_basic_asm.h + * + * Basic asm macros + * + * ARM not implemented. + */ + +#ifndef _VM_BASIC_ASM_H_ +#define _VM_BASIC_ASM_H_ + +#include "vm_basic_types.h" + +#if defined VM_X86_64 +#include "vm_basic_asm_x86_64.h" +#elif defined __i386__ +#include "vm_basic_asm_x86.h" +#else +#define MUL64_NO_ASM 1 +#include "mul64.h" +#endif + +/* + * x86-64 windows doesn't support inline asm so we have to use these + * intrinsic functions defined in the compiler. Not all of these are well + * documented. There is an array in the compiler dll (c1.dll) which has + * an array of the names of all the intrinsics minus the leading + * underscore. Searching around in the ntddk.h file can also be helpful. + * + * The declarations for the intrinsic functions were taken from the DDK. + * Our declarations must match the ddk's otherwise the 64-bit c++ compiler + * will complain about second linkage of the intrinsic functions. + * We define the intrinsic using the basic types corresponding to the + * Windows typedefs. This avoids having to include windows header files + * to get to the windows types. + */ +#ifdef _MSC_VER +#ifdef __cplusplus +extern "C" { +#endif +/* + * It seems x86 & x86-64 windows still implements these intrinsic + * functions. The documentation for the x86-64 suggest the + * __inbyte/__outbyte intrinsics even though the _in/_out work fine and + * __inbyte/__outbyte aren't supported on x86. + */ +int _inp(unsigned short); +unsigned short _inpw(unsigned short); +unsigned long _inpd(unsigned short); + +int _outp(unsigned short, int); +unsigned short _outpw(unsigned short, unsigned short); +unsigned long _outpd(uint16, unsigned long); +#pragma intrinsic(_inp, _inpw, _inpd, _outp, _outpw, _outpw, _outpd) + +/* + * Prevents compiler from re-ordering reads, writes and reads&writes. + * These functions do not add any instructions thus only affect + * the compiler ordering. + * + * See: + * `Lockless Programming Considerations for Xbox 360 and Microsoft Windows' + * http://msdn.microsoft.com/en-us/library/bb310595(VS.85).aspx + */ +void _ReadBarrier(void); +void _WriteBarrier(void); +void _ReadWriteBarrier(void); +#pragma intrinsic(_ReadBarrier, _WriteBarrier, _ReadWriteBarrier) + +void _mm_mfence(void); +void _mm_lfence(void); +#pragma intrinsic(_mm_mfence, _mm_lfence) + +unsigned int __getcallerseflags(void); +#pragma intrinsic(__getcallerseflags) + +#ifdef VM_X86_64 +/* + * intrinsic functions only supported by x86-64 windows as of 2k3sp1 + */ +unsigned __int64 __rdtsc(void); +void __stosw(unsigned short *, unsigned short, size_t); +void __stosd(unsigned long *, unsigned long, size_t); +void _mm_pause(void); +#pragma intrinsic(__rdtsc, __stosw, __stosd, _mm_pause) + +unsigned char _BitScanForward64(unsigned long *, unsigned __int64); +unsigned char _BitScanReverse64(unsigned long *, unsigned __int64); +#pragma intrinsic(_BitScanForward64, _BitScanReverse64) +#endif /* VM_X86_64 */ + +unsigned char _BitScanForward(unsigned long *, unsigned long); +unsigned char _BitScanReverse(unsigned long *, unsigned long); +#pragma intrinsic(_BitScanForward, _BitScanReverse) + +unsigned char _bittest(const long *, long); +unsigned char _bittestandset(long *, long); +unsigned char _bittestandreset(long *, long); +unsigned char _bittestandcomplement(long *, long); +#pragma intrinsic(_bittest, _bittestandset, _bittestandreset, _bittestandcomplement) +#ifdef VM_X86_64 +unsigned char _bittestandset64(__int64 *, __int64); +unsigned char _bittestandreset64(__int64 *, __int64); +#pragma intrinsic(_bittestandset64, _bittestandreset64) +#endif /* VM_X86_64 */ +#ifdef __cplusplus +} +#endif +#endif /* _MSC_VER */ + + +#ifdef __GNUC__ // { +#if defined(__i386__) || defined(__x86_64__) // Only on x86* + +/* + * Checked against the Intel manual and GCC --hpreg + * + * volatile because reading from port can modify the state of the underlying + * hardware. + * + * Note: The undocumented %z construct doesn't work (internal compiler error) + * with gcc-2.95.1 + */ + +#define __GCC_IN(s, type, name) \ +static INLINE type \ +name(uint16 port) \ +{ \ + type val; \ + \ + __asm__ __volatile__( \ + "in" #s " %w1, %0" \ + : "=a" (val) \ + : "Nd" (port) \ + ); \ + \ + return val; \ +} + +__GCC_IN(b, uint8, INB) +__GCC_IN(w, uint16, INW) +__GCC_IN(l, uint32, IN32) + + +/* + * Checked against the Intel manual and GCC --hpreg + * + * Note: The undocumented %z construct doesn't work (internal compiler error) + * with gcc-2.95.1 + */ + +#define __GCC_OUT(s, s2, port, val) do { \ + __asm__( \ + "out" #s " %" #s2 "1, %w0" \ + : \ + : "Nd" (port), "a" (val) \ + ); \ +} while (0) + +#define OUTB(port, val) __GCC_OUT(b, b, port, val) +#define OUTW(port, val) __GCC_OUT(w, w, port, val) +#define OUT32(port, val) __GCC_OUT(l, , port, val) + +#define GET_CURRENT_EIP(_eip) \ + __asm__ __volatile("call 0\n\tpopl %0" : "=r" (_eip): ); + +static INLINE unsigned int +GetCallerEFlags(void) +{ + unsigned long flags; + asm volatile("pushf; pop %0" : "=r"(flags)); + return flags; +} + +#endif // x86* + +#elif defined(_MSC_VER) // } { +static INLINE uint8 +INB(uint16 port) +{ + return (uint8)_inp(port); +} +static INLINE void +OUTB(uint16 port, uint8 value) +{ + _outp(port, value); +} +static INLINE uint16 +INW(uint16 port) +{ + return _inpw(port); +} +static INLINE void +OUTW(uint16 port, uint16 value) +{ + _outpw(port, value); +} +static INLINE uint32 +IN32(uint16 port) +{ + return _inpd(port); +} +static INLINE void +OUT32(uint16 port, uint32 value) +{ + _outpd(port, value); +} + +#ifndef VM_X86_64 +#ifdef NEAR +#undef NEAR +#endif + +#define GET_CURRENT_EIP(_eip) do { \ + __asm call NEAR PTR $+5 \ + __asm pop eax \ + __asm mov _eip, eax \ +} while (0) +#endif // VM_X86_64 + +static INLINE unsigned int +GetCallerEFlags(void) +{ + return __getcallerseflags(); +} + +#else // } { +#error +#endif // } + +/* Sequence recommended by Intel for the Pentium 4. */ +#define INTEL_MICROCODE_VERSION() ( \ + __SET_MSR(MSR_BIOS_SIGN_ID, 0), \ + __GET_EAX_FROM_CPUID(1), \ + __GET_MSR(MSR_BIOS_SIGN_ID)) + +/* + * Locate most and least significant bit set functions. Use our own name + * space to avoid namespace collisions. The new names follow a pattern, + *