Resizing the Linux Root Partition in a Gen2 Hyper-V VM

Resizing the Linux Root Partition in a Gen2 Hyper-V VM

Without a doubt, modern virtualization has changed the landscape of enterprise computing forever. Since virtual machines are abstracted away from the physical hardware, changes in compute, memory, and storage resources become mere clicks of a mouse. And, as hypervisors mature, many operations that were once thought of as out-of-band tasks, such as adding storage or even memory can now be done with little, or even zero downtime.

Hyper-V SCSI Disks and Linux

In many cases, hypervisors are backed by large storage area networks (SANs). This provides shared storage for hypervisor nodes that supports failover clustering and high availability. Additionally, it gives administrators the ability to scale the virtual environment, including the ability to easily add or expand storage on existing virtual servers. Microsoft’s Hyper-V 2012 introduced Generation 2 VMs, which extends this functionality. Among the many benefits of Gen2 VMs, was the ability to boot from a SCSI disk rather than IDE. This requires UEFI rather than a legacy BIOS, so it’s only supported among newer operating systems. Many admins I talk to think this is limited to Microsoft Server 2012 and newer, probably because of the sub-optimal phrasing in the Hyper-V VM creation UI that altogether fails to mention Linux operating systems.

The fact is, however, that many newer Linux OSes also support this ability, as shown in these tables from Microsoft.

More Disk, Please

Once you’ve built a modern Linux VM and you’re booting from synthetic SCSI disks rather than emulated IDE drives, you gain numerous advantages, not the least of which is the ability to resize the OS virtual hard disk (VHDX) on the fly. This is really handy functionality – after all, what sysadmin hasn’t had an OS drive run low on disk space at some point in their career? This is simply done from the virtual machine settings in Hyper-V Manager or Failover Cluster Manager by editing the VHDX.

Now, if you’re a Microsoft gal or guy, you already know that what comes next is pretty straightforward. Open the Disk Management MMC, rescan the disks, extend the file system, and viola, you now automagically have a bigger C:\ drive. But what about for Linux VMs? Though it might be a little less intuitive, we can still accomplish the same goal of expanding the primary OS disk with zero down time in Linux.

On-the-Fly Resizing

To demonstrate this, let’s start with a vanilla, Hyper-V Generation 2, CentOS 7.6 VM with a 10GB VHDX attached to a SCSI controller in our VM. Let’s also assume we’re using the default LVM partitioning scheme during the CentOS install. Looking at the block devices in Linux, we can see that we have a 10GB disk called sda which has three partitions – sda1, sda2 and sda3. We’re interested in sda3, since that contains our root partition, which is currently 7.8GB, as demonstrated here by the lsblk command.

Now let’s take a look at df. Here we can see an XFS filesystem on our 7.8GB partition, /dev/mapper/centos-root which is mounted on root.

Finally, let’s have a look at our LVM summary:

From this information we can see that there’s currently no room to expand our physical volume or logical volume, as the entirety of /dev/sda is consumed. In the past, with a Gen1 Hyper-V virtual machine, we would have had to shut the VM down and edit the disk, since it used an emulated IDE controller. Now that we have a Gen2 CentOS VM with a SCSI controller, however, we can simply edit the disk on the fly, expanding it to 20GB.

Once the correct virtual disk is located, select the “Expand” option.

Next, provide the size of the new disk. We’ll bump this one to 20GB.

Finally, click “Finish” to resize the disk. This process should be instant for dynamic virtual hard disks, but may take a few seconds to a several minutes for fixed virtual hard disks, depending on the size of the expansion and speed of your storage subsystem. You can then verify the new disk size by inspecting the disk.

OK, so we’ve expanded the VHDX in Hyper-V, but we haven’t done anything to make our VM’s operating system aware of the new space. As seen here with lsblk, the OS is indifferent to the expanded drive.

Taking a look at parted, we again see that our /dev/sda disk is still showing 10.7GB. We need to make the CentOS operating system aware of the new space. A reboot would certainly do this, but we want to perform this entire operation with no downtime.



Issue the following command to rescan the relevant disk – sda in our case. This tells the system to rescan the SCSI bus for changes, and will report the new space to the kernel without a restart.

Now, when we look at parted again, we’re prompted to move the GPT table to the back of the disk, since the secondary table is no longer in the proper location after the VHDX expansion. Type “Fix” to correct this, and then once again to edit the GPT to use all the available disk space. Once this is complete, we can see that /dev/sda is now recognized as 20GB, but our sda3 partition is still only 10GB.

Next, from the parted CLI, next use the resizepart command to grow the partition to the end of the disk.

Our sda3 partition is now using the maximum space available, 20.2GB. The lsblk command also now correctly reports our disk as 20GB.

But what about our LVM volumes? As suspected, our physical volumes, volume groups and logical volumes all remain unchanged.

We need to first tell our pv to expand into the available disk space on the partition. Do this with the pvresize command as follows:

Sure enough, our pv is now 18.8GB with 10.00GB free. Now we need to extend the logical volume and it’s associated filesystem into the free pv space. We can do this with a single command:

Looking at our logical volumes confirms that our root lv is now 17.80GB of the 18.80GB total, or exactly 10.0GB larger than we started with, as one would expect to see.

A final confirmation with the df command illustrates that our XFS root filesystem was also resized.

Conclusion

So there you have it. Despite some hearsay to the contrary, modern Linux OSes run just fine as Gen2 VMs on Hyper-V. Coupled with a SCSI disk controller for the OS VHDX, this yields the advantage of zero-downtime root partition resizing in Linux, though it’s admittedly a few more steps than a Windows server requires. And though Linux on Hyper-V might not seem like the most intuitive choice to some sysadmins, Hyper-V has matured significantly over the past several releases and is quite a powerful and stable platform for both Linux and Windows. And one last thing – when you run critically low on disk space on Linux, don’t forget to check those reserved blocks for a quick fix!

Linux File Servers in a Windows Domain

Linux File Servers in a Windows Domain

Let’s face it: Though Linux is experiencing a bit of a renaissance lately, it’s still a Windows world out there. This seems to be especially true in the Enterprise. Users love their Windows. They love their Start Menu, their Task Bar, their Internet Explorer, their My Documents folder and all the problems and pain that go along with it. Don’t get me wrong, I like Windows, too.  And in fact, when it comes to my own use, I’m not much different than the users I’ve supported for the last 20 years. Sure, I try to strike a balance between Linux and Windows for my daily-use machines, and I’m a huge Linux advocate. But ultimately, I find myself gravitating back to Windows for most of my daily tasks, even for email and general web browsing, and certainly for music and entertainment.

But in many Enterprises, Windows’ roots run even deeper. With Exchange Server, SharePoint, Lync (now Skype for Business), MSSQL, System Center and a myriad of other offerings, Microsoft’s server solutions just make sense for many IT shops which have hundreds, even thousands, of desktops and laptops running Windows. Perhaps most ubiquitous of all, however, is the Windows Domain Controller. Microsoft’s Active Directory seems to be the go-to product for authentication and policy management in the Enterprise. In fact, it’s routinely stated that 95% of Fortune 500 companies use Active Directory.  And though the push to, “the cloud,” has some folks decrying the inflexibility of Active Directory as more and more services are moved off-premise, it seems pretty safe to say we won’t see the demise of AD any time soon.

With all this said, according to Red Hat, by 2013 over 90% of Fortune 500 companies relied on Linux in some capacity.  It seems pretty clear that it’s a good bet to have both Windows and Linux skill sets in today’s technology landscape. It also shouldn’t come as much surprise that integrating non-Windows systems into a Windows Domain is big business these days. In this article we hope to demonstrate an example of just that – how to integrate a Linux server into a Windows domain as a file server for Windows clients.

Jump To:

Samba
Why Linux?
Prerequisites
Webmin
IP Address Configuration
DNS Configuration
Installing Samba Components
Samba and Kerberos Configuration
Samba Winbind Options
Joining the Windows Domain
Domain Users & Groups
Extended ACLs
Creating Samba File Shares
Accessing the Share
Configuring AD User Shells & Home Dirs
Conclusion

Enter Samba

For nearly 25 years, Samba has been providing interoperability between Linux/Unix and Windows. Samba allows Linux or Unix-like systems to become Windows domain members in a Windows domain. And though it’s beyond the scope of this article, newer versions of Samba will even allow a Linux/Unix server to act as a domain controller.  In turn, Samba facilitates communication between Windows systems and a Linux/Unix server over the Server Message Block (SMB)/Common Internet File System (CIFS) protocol. In essence, your Windows machine will talk to the Samba server just as though it’s a Windows file/print server.

Why Linux?

So if we’re essentially emulating a Windows server with Linux, why not just use a Windows operating system?  Well, there are a few of scenarios where this configuration may make sense:

  1. Application Compatibility.  You may have an application that runs on Linux or Unix only, but you still need the connectivity that Samba provides.  In this case, you can still run your native Linux application, but allow your Windows clients to access file shares on the server.
  2. Licensing.  Licensing costs for Windows Server may be another factor. For some SMBs, an additional Windows license for a file/print server may be prohibitively expensive.  Many flavors of Linux, on the other hand, are free.
  3. Hardware.  Windows generally requires beefier hardware than Linux.  Even an old desktop in the basement can make a fine home or lab file server.
  4. Software RAID. For others, Linux offers the unique ability to inexpensively provide something that many folks do not trust Windows to do – software RAID. Linux software RAID (aka MDADM) doesn’t have the strict requirements of hardware RAID controllers, and many times can be done less expensively. It also is mostly hardware agnostic. You can typically lift a Linux MDADM RAID array from one box and drop it in another, assemble the RAID array, and find the data intact.  Since hardware RAID controllers are often tied to their disks via specific metadata, this is critical for the hobbyist or home lab, where you may not have an endless supply of identical controllers should one fail.  We’ve even done this with name-brand SOHO NAS appliances which had kernel failures and rescued terabytes of data for a client!

Prerequisites

There are a few things you need to have working before this exercise, however.  Make sure you are at least somewhat familiar with the technologies mentioned.

  1. Domain Controller/Active Directory.  You need to have a working domain controller running Active Directory.  We’ve only tested this configuration on a Windows domain controller, but a Samba 4.0 or newer domain controller emulates this functionality as well.  We’ve been doing this since Windows Server 2008 through Windows Server 2012 R2, so any recent Windows Server should work just fine.
  2. DNS Server.  You also need a properly functioning DNS server, preferably Active Directory integrated.  DNS is critical to the domain join process, so make sure your DNS server(s) are working properly – more on this later.
  3. Linux Server.  This is the member server that is to join the domain.  It doesn’t need anything fancy for this exercise, but must be able to communicate with your domain controller/DNS server.  It can even be a virtual machine for proof of concept, although most home/lab file servers will likely be physical machines.
  4. Windows Domain Member.  This machine can be a desktop, laptop, or virtual machine, as long as it’s joined to the domain and can reach the three servers listed above over the network.

Webmin

Now, we like to perform most operations from the command-line in Linux, as many GUIs typically aren’t very mature in Linux or don’t offer the same functionality as the CLI.  In addition, the CLI gives you an intimate view of applications and configurations you just don’t get from a GUI.  On the other hand, when it makes sense to use a GUI to do something, we won’t shy away from it just to impress our friends.  Webmin is a perfect example of this.  Webmin offers a web-based interface for completing many Linux/Unix administration tasks.  Available for most distributions, it simplifies many operations, eliminating the need to manually edit configuration files.   Joining a Linux server to a Windows domain is one area we like to use Webmin, so our first task will be to install Webmin on our Linux server.  We’ll use Webmin for much of this walk-through, but also show the configuration changes in the file system when possible, so you can become familiar with the underlying files that are affected.

Our Linux server in this case is Ubuntu 14.04, so you’ll see some specificity to Ubuntu, such as using aptitude for package installation.  Most other distros should work much the same as what’s shown in this guide, but obviously some commands and steps will have to be altered.

The simplest way to install Webmin is to download the bits and use the Debian package manager to perform the installation.  First, install any necessary dependencies for Webmin:

Once any dependency issues are resolved, find the latest version of Webmin here and dowload it using wget.  We want the debian version that is offered:

Finally, install Webmin using the Debian package manager:

Once installed, you should find Webmin listening on port 10000.  Keep in mind that distros which have a firewall like iptables enabled by default may need firewall rule modifications to allow access to Webmin.

From your Windows workstation, you should now be able to log into Webmin by browsing to https://servername:10000, where servername is the host name of your new Linux server.  If you cannot resolve it by hostname, IP Address should work as well.  Keep in mind, however, that name resolution of your Linux server will need to work at some point.

IP Address Configuration

It’s best to assign your server a static IP, so you won’t run into any stale DNS record issues.  DHCP may work, at least in the short term, but future problems could arise.  Although IP Address changes can be made via Webmin, this is one area that it’s usually best to be in front of a console.  I also find this configuration change to be easier and quicker from the command line.  Log into the server and edit the interface configuration as follows, substituting the IP and domain information for your network.

Once you’ve saved the configuration file, bounce the network adapter.

 

webmin_network

Now log into Webmin on your Linux server and verify the changes that were just made.  From the left-hand navigation menu, expand, “Networking,” and click on, “Network Configuration.”  The Network Configuration module contains all the settings related to interface configuration, routing and gateways and DNS and hostnames.

 

webmin_if

Select the Network Interfaces link.  Here we should see both the active and at-boot configurations for our Ethernet adapter with the static IP Address we just assigned.  You can also verify the default gateway and DNS server settings for your server here.

 

 

DNS Configuration

As mentioned before, DNS is critical for the domain-join process.  Your Linux server relies on name resolution to locate the domain controller and begin authentication.  We set the preferred DNS servers in the previous step, so the Linux server should be able to resolve the domain controller(s) on your network now.  Test name resolution by running a simple ping test from the Linux server to the domain controller.

 

webmin_hosts

Now we’ll add a hosts file entry for the loopback adapter on the Linux server.  In the Networking > Network Configuration module, select the Hosts Addresses configuration.  Click on the entry for 127.0.0.1 that lists the server’s hostname.  Add the FQDN of the Linux server as the first entry in the list as shown.

 

Again, test the settings by running a simple ping test from the Linux server.  You should see replies containing the FQDN.

We also need to make sure we have name resolution in the other direction.  Since we set a static IP address, we will likely need to create an A-record on the DNS server for the Linux box.  Once the A-record is created, ensure that you have name resolution to the Linux server from both your domain controller and your Windows client.



Installing Samba, Winbind & Kerberos for Authentication

Next, use aptitude to install samba and winbind.  These components will allow you to communicate with the domain controller and use Windows-based accounts in a Linux or Unix environment.

Next, install Kerberos.  Kerberos was developed at the Massachusetts Institute of Technology as a means of providing mutual authentication.  All versions of Windows since Windows 2000 use Kerberos as their default authentication mechanism, and thus is necessary for our Linux server to provide authentication in a Windows domain.

Samba and Kerberos Configuration

Back in Webmin, refresh the modules to display the newly installed applications.  You should now see Samba listed under Servers, and Kerberos5 listed under Networking.  First, click on Kerberos5.  Here, provide the following information based on your environment.

  • webmin_krb5Realm:  Your domain name – IN ALL CAPS
  • Domain name:  Your domain name – in all lowercase
  • Default domain name:  Your domain name – in all lowercase
  • Use DNS to lookup KDC: Select Yes
  • KDC: FQDN of your domain controller – use port 88 unless you know otherwise
  • Admin server: FQDN of your domain controller – use port 88 unless you know otherwise

 

Next, click on the Samba Windows File Sharing under Servers and click on the Windows Networking icon.  Again, provide the following information based on your environment.

  • webmin_winnetWorkgroup: Pre-Windows 2000 (short) domain name – in all lowercase
  • WINS mode:  Use Server – IP of your domain controller
  • Server description: %h server (something descriptive)
  • Master browser priority: 20
  • Highest protocol: default
  • Master browser: Yes
  • Security: Active Directory
  • Password server: FQDN of your domain controller

 

Samba Winbind Options

webmin_winbind

Finally, click on Winbind Options in the Samba module.  Select the options here, and click save.  Frustratingly, the options here seems to have inconsistent results in the configuration file, so we’ll need to verify them in the config.  On the server, backup and then edit the smb.conf file as follows.  You’ll notice a number of the other changes we’ve made have been stored here.

 

 

Locate the [global] section and edit as follows.  Comment out the following two lines if present:

Now add these lines to the end of the global section if they do not exist:

Interestingly, you can see the options reflected in the Winbind Options in the Webmin Samba module.  If you look closely in the Webmin UI, the setting, “Disallow listing of users/groups?” is clearly set to “Yes.”  However, we’ve just set the winbind enumeration to “yes” in the smb.conf file. These settings appears to be contradictory, and you can have strange results if you make changes in the GUI after effecting the changes in the config.  Once things are working, it’s best not to make any additional changes to the Samba Winbind options in Webmin.

Joining the Windows Domain

We’re finally ready to join the Windows domain now.  Issue the following command, where the user, “username” is a domain user that has the permissions necessary to join computers to the domain. It’s always best to use an account with the least amount of privileges to perform an action, but if you are in doubt or if you encounter errors, use a Domain Admin account to rule out permissions issues.  If you’ve carefully applied the settings, however, and DNS is working properly, you should achieve success here and see the new computer account in Active Directory.

Before we move on, let’s break this command down a bit.  The net commands are useful tools for managing Samba/CIFS on your domain-joined Linux server.  In this instance, the ‘net ads join’ command tells Samba that we’re working with the AD command set, hence the ‘ads’ component, while the ‘join’ directive tells Samba that we want to join an Active Directory domain.  The next three options are not specific to Active Directory, but modify the ‘net’ portion of the command.  The -S option specifies the target server (Domain Controller) and the -U specifies the username of the user to use for the domain join.  As mentioned above, this user must have the necessary rights to create objects in AD.  The -k option states that we wish to use Kerberos as the authentication mechanism.

ad_os

The final options, createcomputer, osName and osVer are not required, although they do add some useful features.  First, ‘createcomputer’ creates the new computer account in a specific OU within AD.  This can be handy if you want to keep your Windows and Linux servers separated for policy or organization purposes.  The ‘osName’ and ‘osVer’ options are pretty self-explanatory, but if you like things neatly documented, this will prepopulate the Name and Version fields for the new computer object in AD.

In additional to joining a domain, you can leave a domain, view logon server info, query domain users and groups, and even dynamically update Active Directory integrated DNS records.  The full list of net ads commands can be viewed by simply typing ‘net ads.’

Domain Users & Groups

Next, we need to configure our Linux server to look to the domain controller for users and group authentication.  To do this, we need to simply edit the nsswitch.conf file.  For the passwd and group directives, simply add “winbind” after the compat parameter on each line.  After saving the file, restart all relevant daemons.

We can now verify the configuration as follows.  The wbinfo command let’s us know that Winbind is successfully working and we’re able to connect to the DC to enumerate users and groups.

And now check to verify that the passwd and group databases on the Linux server are populated with the domain users and groups.  The output has been abbreviated a bit, but notice that after the usual passwd file entries, we see our domain accounts beginning with the id 10000.

Extended ACLs

One thing that’s important to keep in mind when we’re talking about Windows file shares, is that permissions, or access control lists (ACLs) are a crucial component to ensure users can see the files they should, but are restricted from those they shouldn’t.  In the Windows world permissions are further divided into two components – share permissions and file system permissions.  Without both properly set, users may experience issues with access.

First, let’s discuss file system permissions in our Linux-in-a-Windows-domain environment that we’ve created.  Traditional Unix permissions aren’t much good to us if we want our new Linux file server to work like Windows, as we would be limited to a single user and group on each directory or file.  You certainly may have a situation where you’d want both Accounting and Finance to have read-write access to a directory, but perhaps HR to only have read access to that same directory.  Enter Linux Extended ACLs.  We dig into the Extended ACL package in detail here, but suffice to say that Extended ACLs are the icing on the metaphorical Linux file server cake.  Extended ACLs gives us more Windows NTFS-like permissions; without them much of the power of Linux domain integration is lost.  To see this in action we need to install the acl package with the following command.

We’ll also need a directory to share out so let’s assume we have an empty 5 GB partition to work with.  First, we need to create an EXT4 file system on the partition as shown below.

Now we need to mount our partition on the server.  First, create the directory to hold our shares, and a subdirectory in which we want to mount our partition.

Next, edit the fstab file to auto mount our new partition to ensure it persists after a reboot.  I prefer to do this by using the disk UUID rather than the device letter and partition number (i.e. sda1, sda2, sdb1, etc.), as device letters may change if disks are swapped around on a SATA or SAS controller, a new controller or disk enclosure is added, or if disks are moved to a different system.  Disk UUIDs are easily determined by listing the devices as shown.  Locate the disk UUID for /dev/sdb1 and use the unique identifier in the fstab file.  Note also that the our disk is to be mounted with the acl option.  This enables us to use the extended ACLs package we just installed.

Finally, mount the partition from fstab.  We can then easily verify the newly available space by taking a quick peek at the disk file systems with the df command.

Now that we have a place to share our files, let’s modify the traditional Unix permission set on the shares directory, but leverage the domain groups we now have available.

Note the double backslash when setting permissions.  To make the Windows users and groups work, we must escape the backslash that typically separates the domain\user and domain\group since it’s a special character in Linux.  The first command sets the owner to a domain user called shareadmin; the second command sets the group to a domain group called share admins.  Finally, the last command sets the traditional POSIX rw- permissions.  So, there’s not much new here, but we can start to see the additional flexibility our AD integrated server offers.

Next, let’s consider the same directory called files, but suppose we want further granularity than just the owner and group permissions.  This is where the extended ACL commands become quite powerful.  To first take a look at any ACLs that exist on this directory, we’ll use the getfacl command.  Getfacl will not only show us the traditional UNIX permissions, but also any additional ACLs applied to the file or directory.  Again, not much to see here yet, but this will start to take shape soon.

The setfacl command allows us to set ACLs on file or directory, separate from the traditional UNIX permissions set above. The setfacl -m parameter specifies that we want to modify the ACL, and the u: or g: parameter indicates whether we’re modifying a user or group permission.  Additionally, the -d parameter, along with the ‘chmod g+s’ command, gives us the ability to set default ACLs on the directory, so that new files and subdirectories inherit the parent ACL.

So in the above example, we’re turning on inheritance, setting the default permissions for the default user and group, and we’re also assigning three separate group default permissions to this directory.  The first two groups, Domain Admins and Share Admins both have read/write/execute, while the third group, Backup Admins, has read and execute only.  Now taking a look at getfacl again on this directory, we can see a clear difference from our vanilla directory:

Finally, we want to grant explicit ACLs on the parent folder – remember the previous ACLs we assigned were only defaults.  These commands look similar to the default ACLs, less the -d parameter.

Now we have a full set of permissions, and any new subdirectories will inherit these permissions as well.



Creating Samba File Shares

Now for the part we all came for – creating the file shares.  Again, this is one of the operations that just plain easier to manage in Webmin.  In the Samba module, click on the “Create a new file share,” link.  Here, provide the basic share information.

  • createshareShare name:  Something logical but succinct, such as Music or Pictures
  • Directory to share:  The directory on the Linux server that contains the files we want to share out
  • Available:  Yes
  • Browseable:  Yes (No, if you want the share to be hidden)
  • Comment:  Not required, but can be a longer description of the share contents

Once done, click the Create button to commit the settings.  You should now see the share in the Samba share list.  Click on the new share name in the list and click the ‘Security and Access Control’ link. Recall before we said that file server permissions were comprised of two components – file system and share permissions.  We’ve configured the file system permissions with Linux Extended ACLs, but here we’ll set the share permissions.

On the Edit Security page, provide the information for share permissions.  We will use the same groups we discussed in the setfacl examples.

  • sharesecurityWritable:  Yes
  • Guest Access:  None
  • Limit to possible list?  No
  • Hosts to allow:  All (unless you choose to restrict access by host)
  • Hosts to deny:  None (unless you choose to restrict access by host)
  • Revalidate users?  No
  • Valid groups:  “domain\share admins” “domain\domain admins” “domain\backup admins”
  • Read only groups:  “domain\backup admins”
  • Read/write groups:  “domain\share admins” “domain\domain admins”

Click the Save button when complete.  Regarding the group information, be sure to provide this information as shown here – each entry should be enclosed in quotes, with a single slash between domain and group, and the list should be delimited by a single space.

Here’s what this new share looks like in the smb.conf file:

Finally, restart the samba daemons to fully implement the share.

Accessing the Share

run

Now, from our Windows client, we should be able to access our new share.  First, ensure you’re logged into Windows as a user that is in one of the groups we assigned to the share.  Then, from the run line, simply type \\servername.

You should now see a familiar Windows Explorer window and you should see the new file share.  You should also be able to create, copy or move files and folders to the new share.  Try this by creating a folder called ‘Dir1’.  If we then take a look at Dir1 with getfacl, we should see a pattern similar to our previous examples.  Note that the only exception is that the owner is the user who created the file, in this case user1.

writepermissions

The beauty of this configuration is that we can now manage files and subdirectories from Windows, using the familiar right-click > Properties context menu.   As a final test, look at the properties for Dir1 from your Windows client.  On the security tab, click the ‘Edit’ button to change permissions.  Highlight Backup Admins in the list of group or user names and check the box for Write permissions under the Allow column.  Click, ‘OK’ and ‘OK’ again to close the dialogue boxes.

Now let’s look at Dir1 again with getfacl.  Note that the Backup Admins group now has rwx permissions.

Configuring AD User Shells & Home Dirs

As a final exercise, you can also configure your domain-joined Linux server to leverage Samba for single sign-on, so Active Directory users may log into the Linux file server, using Kerberos authentication.  First, to automatically have home directories created for domain users upon login, create the following directory.  This folder will house the home folders for domain users, keeping them separate from any Unix users, and avoiding any naming collisions.

Add the following line to the PAM common-session file.

Now add the Domain Admins group to the sudoers file so that any Domain Admins will have sudo capabilities upon login.  Additionally, set the group_source to dynamic in the sudo.conf file.  This will allow any member of the Domain Admins group to also manage Webmin.

Finally restart the samba, winbind, and webmin daemons to enable these settings.

Conclusion

Though not without a few quirks, a Windows domain-integrated Linux file server is a great alternative for those environments in which running a Windows file server doesn’t quite fit the bill.  Linux file servers are flexible, can be relatively inexpensive, and can give you excellent performance and reliability when properly configured. This walk-through hopefully gives you the necessary information to make Linux work nearly seamlessly for you and your users in your Windows domain.

Pass-through Disks vs. VHDX and the VhdxTool

Pass-through Disks vs. VHDX and the VhdxTool

When evaluating storage options for a Microsoft Hyper-V guest machine, there are several options available these days. Solutions like iSCSI and Fibre Channel present block storage directly to virtual machines via Virtual Switches and Virtual SANs. While offering physical server-like performance, these solutions require significant hardware, infrastructure and the skill-sets to manage them. Two popular options that don’t require extravagant disk subsystems are pass-through disks and VHD/VHDX, however. Both offer the ability to attach the disk to the guest in the virtual machine settings, so there’s little configuration in the virtual machine itself. Let’s take a quick look at these two options.

Hyper-V Pass-Through Disks

For those not familiar, pass-through disks are disks present on the Hyper-V server that could either be local to the hypervisor or they could be LUNS mapped to the hypervisor via iSCSI or Fibre Channel. In this configuration, the disks are reserved on the hypervisor to enable exclusive access to the disk by the VM. This is done by initializing the pass-through disk in Disk Manager on the hypervisor, and then placing the disk in an Offline state.

You can see what this looks like in both diskpart and disk manager.

diskmgmt

Virtual machine configuration for pass-through disks is straightforward as well. Once the disk is offlined in the hypervisor, simply open the settings for the virtual machine and click on the storage controller and add a hard disk. Select the radio button for, “Physical hard disk:” and choose the appropriate disk from the drop-down. Again, this MUST be an initialized disk, that has been placed Offline in Disk Management on the hypervisor.

phy_disk

Now that you’ve seen a bit about pass-through disks, let’s talk about the pros and cons of this type of storage.

Pros:

  1. Performance.  This is the most oft cited reason for using pass-through disks.  Proponents like to talk about the advantage of not virtualizing the disk, and the near-physical performance of pass-through disks.

And, that’s about it.  Performance is really the only reason you’ll hear for using pass-through disks.  And while performance is a great reason to select a particular configuration, many experts would argue that the advantage of pass-through disks over VHDs even in older versions of Hyper-V (2008 and 2008R2) was small.  Typically, numbers such as 15%-20% are thrown around.  With the improvements in Hyper-V 2012 and 2012R2 and the VHDX format, this advantage shrinks.  Use fixed rather than dynamic VHDXs, and the advantage shrinks further, to “virtually” nothing (pun intended).

Cons:

  1. Not portable.  Pass-through disks are not easily moved.  Rather than being able to copy or migrate a virtual disk to new storage, a pass-through disk must be physically moved.  Given the myriad of server and storage controller configurations, this is not typically an easy affair.
  2. Uses the entire disk.  Since the whole disk is reserved for the virtual machine, no other virtual machines can use the disk.
  3. Not recommended for OS installations.  OS installations can be problematic on pass-through disks since the VM configuration files must be located on another disk.
  4. No host-level backups.  Backups must occur at the guest level rather than the host level, since the VM has exclusive access to the disk.  As a result, backup and recovery becomes significantly more cumbersome.
  5. Difficult live-migrations.  Live migrations require storage attached to a virtual machine to migrate along with the VM.  Hyper-V clusters can be configured with pass-through disks, but it requires special considerations, and it’s not an optimal or recommended configuration.
  6. Cannot take snapshots.  Snapshots are a super-handy tool and an important advantage of using virtual machines over physical servers.  Losing this ability is a huge con.
  7. Cannot be dynamically expanded. Although dynamic disks are generally not recommended for production scenarios, they do have their use cases. Pass-through disks do not offer this functionality.



VHD/VHDX

Clearly, there are numerous drawbacks to using pass-through disks.  Now let’s take a look at the alternative in this discussion – VHD/VHDX.  This is Microsoft’s implementation of virtual disks and is now the preferred method for storage in Hyper-V.  Generally, there’s no reason to use VHDs over VHDXs with modern hypervisors and VMs (there are a few environment-specific reasons beyond the scope of this article to use VHD).  VHDX supports much larger disks (64TB vs. 2TB) and is considerably more resilient to corruption, especially after a crash or power loss.  VHDX also offers online resizing, allowing you to grow or shrink a virtual disk while the VM is running.

Looking at the pros and cons of VHDX, it’s basically the reverse of pass-through disks. Like pass-through disks, VHDXs can be stored on local disks on the hypervisor or SAN LUNs attached to the hypervisor. And given there’s at most a few percent advantage in performance of a pass-through disk over a fixed-size VHDX, it’s no wonder that Microsoft pushes VHDX as the preferred storage method for VM storage.

Creating VHDXs is also a straightforward affair. From Hyper-V simply select New > Hard Disk from the Action Pane in Hyper-V Manager.
vhdx_create1

Next, select VHDX unless you have a specific reason to use the VHD format.
vhdx_create2

Choose the type of virtual hard disk you’d like to create.
vhdx_create3

Select the name and location for the new VHDX.
vhdx_create4

Now choose the size of the VHDX.
vhdx_create5

Finally, click, “Finish,” to create the VHDX.
vhdx_create6

Attaching the VHDX to the VM is much like with pass-through disks. In the VM settings, simply select the virtual hard disk radio button and provide the path to the VHDX.
vhdx_attach

So far so good. Now this is where is one tiny wrinkle rears its head. If you’re following along and creating a VHDX while reading this, you’re likely still waiting for the previous step to complete, especially if the virtual disk is a large one, and you’re not using enterprise SSD storage. If you’re like us, and creating VHDXs on a small mirror or large, but relatively slow RAID arrays (i.e. SATA RAID-5 or RAID-6), this process can take a while. For something like a 4TB VHDX on slower disks, this can really take a while.

So we have to ask, “what’s happening during the VHDX creation that takes so dang long?”  Well, as it turns out, during this process, the entire space required to store the VHDX is zeroed out on the disk.  This is a conscious decision by Microsoft, as there are security implications in not doing so.  As Hyper-V Program Manager Ben Armstrong explains here, VHDX creation could be nearly instantaneous. If the zeroing is not done, however, data may be recovered from the underlying disk(s).  This would be a huge security no-no, of course, so Microsoft has no choice but to opt for safe route.

But what about for new disks on which data has never been stored?  Clearly, there’s no security risk there.  Many IT Pros would prefer the ability to decide for themselves whether or not a quick VHDX creation is appropriate.  After all, we make decisions that have major security implications every day in our jobs.  Microsoft has provided a tool to do just this for VHDs in the past.  Unfortunately, Microsoft did not release such a tool for VHDX files.

What about an option within Hyper-V?  Maybe a feature request for the next version?  Not likely.  As Mr. Armstrong notes, “the problem is that we would be providing a “do this in an insecure fashion if you know what you are doing checkbox” which would need a heck of a lot of text to try and explain to people why you do not want to do it – and then most people would not read the text anyway.”

VhdxTool

Enter VhdxTool, from the good folks over at Systola.  They’ve picked up where Microsoft has left off and provided a tool to create and resize VHDXs nearly instantaneously, even with multi-terabyte disks.  They explicitly state this software is to be used at your own risk – it should only be used on new disks that contain no data, and not on disks that may contain data, especially when that VHDX may be accessed by end-users.

So how fast is it?  We tested VhdxTool on four 4TB drives containing 4TB VHDXs, with pretty astounding results.

So in a little over one second, a 4TB VHDX was created to attach to our VM. Not bad. Additionally, there are also a number of command line options to accommodate any scenario. These are well documented on Systola’s site, but allow you to create, extend, convert, upgrade or view VHDXs.

Conclusion

Due to it’s many advantages, using VHDXs in place of pass-through disks is clearly the way forward in Hyper-V.  If you’ve ever had reservations about using large VHDX files due to long creation times, Systola has provided an indispensable tool that gives IT Pros the option to fast-create VHDXs.  Just remember, use good discretion when doing so and be sure to keep your data safe.

List Directories and Files with Tree

List Directories and Files with Tree

On one of our backup servers, we run StableBit’s DrivePool with great success. As we’ve mentioned, this is a great program that allows you to pool disparate hard drives on a Windows Desktop or Server and has some great features and options. We use it to simply pool a number of drives to provide a large (20+ TB) backup target for our uSANs. After all, it’s backup, and in a home lab, you may not want to spend extra money on parity drives in your backup server when you already have parity and redundancy at other levels. And though it’s been working without fail for some time now, there’s one nagging thought that always lurks in the shadows for me.

As with any virtual file system layered on top of a drive pool, not knowing exactly where your files are is just how things work. After all, that’s what it’s designed to do – obfuscate the disk subsystem to provide a single large file system to place your files. Copy your stuff to the pool and let the software do the rest. To the user, all your files transparently appear in one neat and tidy place.

Perhaps it’s my OCD, but I still like to know where everything is. In a pinch, say if a backup drive fails, I like knowing exactly what’s gone. It’s like the old saying, “you don’t know what you don’t know.” “But Bill,” you say, “if a disk fails, simply rerun your backup scripts and let the system do it’s thing.” I know, and you’re exactly right, but you still can’t convince my OCD of that.



So, without further ado, here’s a simple command-line tool in Windows that will output a list of your files for reference should you need it — tree. Tree is included with nearly all versions of Windows and it’s quite easy to use. In it’s simplest form, tree simply outputs a list of directories, beginning with the current directory, and does so in a visual tree form that shows the directory structure. In system32 for instance, it looks like this:

Tree only has a couple of command line switches, but both can be useful.  Running tree with /F also displays the names of the files in each folder. As you can imagine, the output could get quite lengthy for a folder like system32, but sending the output to a logfile allows you review or search the output as needed. Using the /A outputs the results using ASCII characters instead of extended characters.  This is important when sending the output to a plain-text file, in which extended characters may not appear properly.

The simple command just looks like this:

Output is neatly sent to a plain-text file, which documents the file and folder layout.
tree_log

For our backup pool, we simply send the output tree to a log file as part of a daily scheduled task.  Should a drive in the pool fail, we can simply reference the log file for that day to determine exactly which files were lost.

Clear the Disk Read-Only Flag in Windows

Clear the Disk Read-Only Flag in Windows

While recently adding a new disk to one of our backup servers, one of the disks changed device letters in Linux. Ordinarily this is not a big deal, but since this particular disk was a iblock device in an LIO backstore, and was defined by the /dev/sd[x] notation, it was no longer listed correctly. Oddly, the disk was still listed in the Disk Manager on the hypervisors, but any attempt at I/O would result in errors. The disk was ultimately removed from the LIO configuration, which then caused the LUN to drop from the hypervisor nodes.

After adding the disk back to LIO using a slicker method as detailed here, the disk reappeared on the hypervisors, and we reconnected the disk to the VM in Hyper-V. However, after adding the storage back, we noticed the LUN from LIO was marked as read-only in the virtual server, and would not permit any writes. Should you run into a similar situation, the fix is usually pretty simple, as noted below.

First, start the diskpart utility from a Windows CLI and list the available disks:

 

Next, select the disk in question, in this case Disk 6. Notice that when we look at the disk details in diskpart, this disk is definitely listed as read-only:

 

With the disk still selected, clear the readonly attribute for the disk with the following command:

 

The disk should now be listed as “Read-Only: No,” and available for writing. You can verify its status with the detail command as before.

We’re still not quite sure what caused this little issue, as we’ve removed and added several disks back in LIO without this cropping up. Perhaps it was the less than graceful removal of the disk from the hypervisor while it was attempting IO. Whatever the case, though an old utility, diskpart can still prove to be a useful tool when the need arises.