Mailbox Videos
newest 100 mailbox videos / mailbox widgets / media rss:

Author: carlsonmailbox Added: Wed, 25 Jun 2008 13:52:56 -0800 Duration: 113 * Carlson's security mailboxes will give you peace of mind when it comes to the security of your mail! * These mailboxes were designed to prevent identity theft and vandalism. * After mail is deposited, the mailbox door will automatically shut and the unique hidden trap door will open. * Your mail goes out of sight and into a secure, locked holding area located on the back of the mailbox. * Carlson's mailboxes offer great security for mail-ordered medication and medical supplies! * Holds your mail while you are away on vacation! * They are constructed of lightweight yet durable weatherproof materials & have a holder for outgoing mail.

This video post was inspired by the blog Pioneer Woman and my daughter s love of stickers. When I was childless I swore I wouldn t be one of those moms whose back right window is littered with stickers. Right now there are two. Share

Author: rkbsint Added: Mon, 16 Jun 2008 10:20:11 -0800 Duration: 163Ron Williams 404-797-2735 http://www.workingwithron.info cash gifting Check GFL100 (Gifts For Life) cash gifting gifts for life scam gfl100 (review) out this new program cash gifting that is literally exploding the success of my new team members ...

Double Your Gas Mileage by Running Your Car on Water. Costs $49. For more information, please visit: http://www.winpokertoday.com/water.html . . . . . . . . . You may have been looking for: Fred on Father's Day (1.7) Fred celebrates Father's Day even though he doesn't live with his dad. Category: Comedy Tags: Fred on Father's Day State Pen Death Row Mailbox Letter Sorry, we can not deliver this video, but we can give you: How to Convert Your Car to Run on WATER Double Your Gas Mileage by Running Your Car on Water. Costs $49. For more information, please visit: http://www.winpokertoday.com/water.html Author: runcarwater13 Keywords: Fred on Father's Day State Pen Death Row Mailbox Letter Added: June 13, 2008

Farnsworth and the Fox First Look - Hancock Author: CBS Keywords: Fred on Father's Day State Pen Death Row Mailbox Letter Added: June 13, 2008

(1.7) Fred celebrates Father's Day even though he doesn't live with his dad. Author: Fred Keywords: Fred on Father's Day State Pen Death Row Mailbox Letter Added: June 12, 2008

(1.7) Fred celebrates Father's Day even though he doesn't live with his dad.

Author: bkball101 Added: Thu, 15 May 2008 00:49:31 -0800 Duration: 12we were just bored and poped some crackers in our friends mailox

Author: bkball101 Added: Thu, 15 May 2008 00:49:31 -0800 Duration: 12we were just bored and poped some crackers in our friends mailox

Two morons with no lives set out on an epic adventure to get their taxes to the post office five day late. With no time to lose (except the time they lost) they try to find their way to a mailbox. Author: mullinator7 Keywords: mullinator7 conor jones and the forbidden mailbox indiana spoof morons stupid funny Added: April 22, 2008

http://www.myspace.com/davidchoimusic Author: davidchoimusic Keywords: QnA with David Choi davidchoimusic mailbox Added: April 4, 2008

Doug Madison of Woodbridge, VA explains why he speaking out against the Prince William County Immigration Resolution, even though he voted for its proponents in last November's Virginia State Election. Author: 9500Liberty Keywords: immigration northern virginia prince william county doug madison mailbox junction corey stewart illegal undocumented Added: April 4, 2008

If your mailbox affected by spam emails Watch this video

A car that runs into a fence does not completely leave the scene. Author: Featureman Keywords: Fence wreck car automobile tutorial Tom Willett mailbox Added: March 2, 2008

Заведи почту на www.gmail.com. Прямо сейчас!

Our first movie, made in 2004. Sequels have been in the writing stage ever since then, even though this movie never actually had a writing stage. Author: sumkeep41 Keywords: riders on the storm sam patton cal webb jake taylor doors mailbox you know it not gonna let that fly Added: January 29, 2008

It's been a while since we announced an update to Exchange 2007 Mailbox Server Role Storage Requirements Calculator. Yesterday we have updated the calculator to version 13.0. Updates: We have updated the log generation numbers per message profile to be in line with our updated guidance. In v11.8, we decided to list the database cache per mailbox in the Storage Requirements results section. However this lead to confusion because it was named Memory Profile / Mailbox which implied that you would only utilize the associated amount of memory with the message profile (i.e. 5MB with Heavy profile), however that is not always the case. For example, 1200 2GB Light message profile mailboxes only requires 5GB of RAM (1200 * 2MB + 2GB), however the design requires 13 databases, which with SP1 requires 6GB of RAM. ESE will utilize 4GB of that RAM for the cache. As a result, 4096MB / 1200 3.5MB per mailbox. So to make this clear, we have changed this text to be Database Cache / Mailbox which indicates how much cache is available per mailbox. In the scenario where you override the IOPS prediction formula for your mailbox tiers, we have adjusted the Read:Write Ratio input to allow you to enter any read percentage you would like, rather than restricting you to a few key ratios. We updated the Database Reads / Mailbox calculation description. We updated the Log Replication Requirements worksheet, simplifying the data displayed in the results section. We have included new functionality for log replication requirements. You now have the input options for entering your network link type and its associated latency. These options are then used to recommend TCP/IP optimization settings for Windows Server 2003 when utilizing geographically dispersed clustering and/or standby continuous replication. In addition, if the chosen network link cannot sustain the throughput requirements for log replication, we will recommend an appropriately sized network link and Windows Server 2003 TCP/IP optimization settings. For full list of updates (per version), go here. For the explanation of different tabs and how the calculator works, go here. Yup, we updated that too! Finally, to get the new calculator - go here. - Ross Smith IV Share this post :

My mailbox size is 7.4GB. I send/receive around 200 emails a day; so that 7.4GB of email goes back several years. I don't use too many rules so most of my email ends up in my Inbox (30k items). If you have read Exchange mailbox sizing guidance, you will notice that my mailbox size is higher than the recommended max OST size (2GB), and I store more items in my Inbox than the recommended (5k). Since I am one of the contributors to this guidance, I felt I should come clean (by writing this blog); and explain how I use my email that meets the following criteria: Large Mailbox (several years worth of email stored in the Exchange Store) No PST usage Good laptop cached mode user experience Good workstation/home computer cached mode user experience The ability to search my entire mailbox My email processing does not over burden the server Before I get started, I should probably tell you what hardware/software I am using Software Office Workstation Home Computer Laptop Windows Vista SP1 RC1 (x86) 2 core 2.66ghz 2 core 3.2ghz 2 core 2Ghz Office 2007 SP1 4GB Memory 2GB Memory 2GB Memory 10K SCSI disk 7.2k SATA disk 5.4K SATA disk *The software is the same across all machines. **The disks sited are those which host my Outlook 2007 OST (I am the Exchange Storage Program Manager; I have lots of disks in all of my computers). Not surprisingly, I have a different user experience processing my mailbox depending upon which machine I am on. Also not surprisingly, my experience has changed as my mailbox size has grown. As my mailbox began to exceed 2GB, I noticed that my laptop experience began to degrade. It took longer to sync down new messages, longer to do sorts etc. As my mailbox exceeded 4GB, I noticed the same thing on my home computer. I now experience the same slowness on my office workstation with my 7.4GB mailbox (don't ask what my laptop experience is like). This is expected since each machine has a different performing hard disk (which my Outlook 2007 OST is stored on) and the fact that Outlook storage performance will slowly degrade as the mailbox size increases. Outlook development folks have the same max mailbox size as me (~10GB), so they are also very much aware of the performance issues associated with a large OST; and are working toward addressing the issue in future versions of Outlook. They made great progress in improving OST scalability with Outlook 2007 Sp1, but I hear there is still work to do. My background is in software performance (especially storage performance); so I couldn't live with the status quo. I was stuck, I needed my large mailbox; but I also needed a great/fast user experience so I could effectively process my mailbox. All of my machines had sufficient memory (2GB or more) so I couldn't solve the problem by adding memory (to provide the Windows System Cache with more memory to buffer the OST IO's). I basically had the following options: 1. Increase the IO performance for the OST. This would involve doing one of the following: a. Installing the fastest hard disk available (15k 2.5 SAS). This would require a new disk controller. b. Building a RAID10 array of several disks. Since I am a storage guy, the RAID10 approach (combined with a nice battery backed write caching array controller) was rather appealing. c. Installing a flash disk. Flash is still a bit too expensive and the write performance does not match the read performance (not even close) on today's devices. I wanted a good user experience both when Outlook 2007 was syncing down lots of new messages, as well as when the OST was up to date. 2. Run Outlook 2007 in Online Mode. This moves the IO burden from the client to the server and doesn't address the disconnected laptop scenario. 3. Limit the amount of email synced to my OST. Outlook 2007 has the flexibility to limit what folders get synced to your OST. You can reduce the size of your OST by configuring sync policies on a per folder basis. By configuring this, I could have my 7.4GB mailbox but only sync down a subset (say 2GB) to my OST. Option 1 was what I was originally targeting but it didn't make much sense to solve the IO problem only on my workstation and home computer (2.5 SAS disk or RAID array); but not solving the problem on my laptop. A flash disk would work for all my computers, but I wasn't willing to invest that much cash to solve this problem; nor was I happy with the random write performance of these devices. Option 2 was a non starter since it breaks for my disconnected scenarios (Wi-Fi is not quite ubiquitous). I could use Online Mode for my workstation and home computer; but I would be adding additional burden to the server in the process; and still wouldn't have a laptop solution. This left me with Option 3; limit the amount of data I sync to my OST. This is what I did. Step 1: Designate a small set of archive folders and move old items in to them (or us MRM to automate this) We utilize MRM (Messaging Records Management) policies in our Exchange 2007 deployment. The policy is configured like this: Any email older than 1 year gets moved to Managed FoldersWill Expire folder. I have 90 days to move any email moved to this folder to another Managed Folder with a longer expiry policy before it gets deleted. Managed FoldersResearch and Development is a Managed Folder that has no expiry policy. I move messages in to this folder that are related to Research and Development that I want to keep longer than a year. The majority of my email relates to R Research and Development (No Expiry) 2004 2005 2006 2007 Personally, I manually manage moving old R and all of my email that is older than one year is stored in the year based folder hierarchy underneath Managed FoldersResearch . Step 2: Configure Outlook 2007 to not sync the archive folders Now that my mailbox is segmented, I want to configure Outlook 2007 (Cached mode) to only sync the email for the past year. I rarely access email that is older than 1 year (a couple times a month at most), so it is a worthwhile trade off to sync only recent email to my OST and thus improve the client experience. If I need to access email that is older than a year, I either bring up Outlook 2007 in Online Mode or use Outlook Web Access (OWA). Since accessing +1year old email is so rare, I have yet to hit a scenario where I was on the road and disconnected from a network and needed to access an old email. If it was a critical situation and I needed to access that email immediately, I could always access it via my Smart Phone and Exchange Active Sync. Configuring Outlook 2007 to not sync the archive folders is straightforward: 1. In Outlook 2007 (Exchange Cached Mode), right click the folder you want to set the sync policy on and choose Properties (e.g. Managed FoldersResearch and Development2006) 2. Click the Synchronization tab, and then click Filter. 3. Click the More Choices tab. 4. Set the Size (kilobytes) to less than 0. This is a simple way of configuring Outlook to not sync anything for this folder. 5. Click OK 6. If you already synced items to this folder and want to clean them out of the OST, then you need to go back to the Folder Properties General tab and click Clear Offline Items. This will expunge already synced items from the folder based on your new policy. I usually perform these steps on a newly created OST (to prevent the archive folder syncs occurring in the first place). 7. Follow steps 1-6 for every archive folder you do not want to sync to your OST. I recommend using a just a few archive folder for this reason. 8. Follow steps 1-7 every time you create a new Outlook Cached Mode profile on any computer. I followed these steps for my office workstation, my home computer and my laptop. Step 3: Enjoy the results I have been very happy with Outlook 2007 performance after segmenting my mailbox and only sync'ing a year's worth of kept email (~2GB). This approach has allowed me to meet all of my criteria: Large Mailbox (several years worth of email stored in the Exchange Store) I have access to several years worth of email from any device No PST usage Since my mailbox is so large, I do not need PST's. PST's are a security/reliability risk as well as being a pain to manage and use. Life is much simpler with all of my email in one place, my mailbox (accessible via all of the standard clients). Keeping all of my email in my Exchange mailbox is the best/safest place to store it. It is stored on RAID10 storage, replicated via CCR, and is backed up on a regular basis. Before my large mailbox, my PST's were stored on non-raided storage, not replicated and backed up maybe once or twice a year. Good laptop Outlook 2007 cached mode user experience By segmenting my mailbox in to two buckets (less than a year old and over a year old) and configuring Outlook 2007 folder sync policies, I have dramatically improved the client performance; even on my 5.4k laptop disk. Good workstation/home computer cached mode user experience Outlook 2007 cache mode performance screams on my workstation and home computers (again, thanks to mailbox segmentation and Outlook 2007 folder sync policies). The ability to search my entire mailbox For those few times a month I need to access email that is older than a year, I just do a quick search in OWA or open up Outlook in online mode. My email processing does not over burden the server By running all of my clients in cached mode, I reduce my personal impact on the server (IO and CPU processing), by offloading some of the mail processing work to my client. The server costs do increase as the mailbox size increases when running in Online Mode. Running in cached mode solves this. I have found that a large mailbox, combined with a few Outlook configuration tweaks can make for a great user experience. I have the best of both worlds; my Outlook experience is snappy, and I have access to all of my email from any standard Microsoft client. Till Outlook improves the OST scalability further, this is the configuration I live with on a daily basis. I look forward to the day where I can keep full copies of my mailbox synced to my client; but for now, I am satisfied using this creative approach . To most of you, a 7.4GB mailbox is pretty big (huge even). I have worked with several customers recently who still have 25MB max mailbox sizes (I would fill it up with my profile in 2.5 days!). I have also worked with customers who have unlimited mailbox sizes and have users with mailboxes in the 20GB - 60GB range! I have not tested this selective sync folder approach to 60GB mailboxes, but in principle it should work. It has got to be better than the 60GB OST experience! - Matt Gossage Share this post :

You've been using Outlook for years now and you've probably established some delivery rules for yourself. Maybe mail from your manager is automatically routed to a subfolder of your inbox. If you're using Outlook 2003 or later, you've got an automatically maintained rule to handle junk mail. If you've ever set your Out Of Office, that's handled by a rule too. But how do rules actually work? What's the implementation like? Obviously, I won't get into the grimy details (trade secrets and all), but I can pass along the basics. First, the rules infrastructure is fully documented on MSDN. Those among you brave enough to explore this documentation may be inspired to write a little app which will enumerate your inbox rules and print them out on the console for detailed inspection of just what Outlook creates. I wrote such an app for internal diagnostic purposes (which means I most likely can't share it with you, sorry). Oh wait! Someone else has already published something here! A rule consists of two fundamental properties, and a bunch of other support properties which mostly won't matter for this discussion. The important ones are the rule's conditions, and the rule's actions. Simplistically, if the incoming mail passes the restriction, the rule engine subsequently carries out the actions. The rule engine itself is completely agnostic to the intentions of the rule creator. In other words, the rule engine doesn't care what the title of the rule type in Outlook's wizard is it only applies the restriction and then if that passes, it carries out the actions. The conditions are expressed as a MAPI Restriction. As each mail is delivered, the restriction on each rule is applied to the incoming message. The restriction describes a complex property value comparison tree, such as (the received time somedatetime AND the sender's display name starts with Bob AND the body contains Loser ) OR (the message size is greater than 2k). Such restrictions are also used for searching for messages, filtering views, and so on. In this case, the restriction is applied to the incoming message. This means that rules cannot check against dynamic values, such as the current system time or how big the mailbox is. It's constrained to checking properties of the message against constant values. One exception to this is how the Junk Mail rule works, which I'll describe later. Outlook has a variety of pre-canned restrictions that it uses and I won't go into the exact nature of each one (yes, I know, you're just burning to know what the precise nature of each of these is, but you can use the sample app I linked to above to study the precise nature of each of the rule types). I will point out an important design point though: rules which are of the form FROM some DISTRIBUTION GROUP actually means if the sender is a direct or indirect member of that DL . This often confuses people because they create a rule like mail from my team DL , move to the my team folder . What ends up happening is all mail from anyone on the my team DL starts having their mail moved to that folder. If you think about it, it makes complete sense. However, more often than not, folks really wanted the rule mail SENT TO my team DL , move it . If the message meets the restriction criteria, the actions are then carried out. While Outlook rarely creates rules with multiple actions within, it's possible to have a list of actions on one rule. The possible actions are: Move the message to another folder* Copy the message to another folder* Reply to the message (with a given template message) Send an Out Of Office reply (with a given template message) Fail delivery with a specific error code Forward the message to another address Delegate the message to another address (a lot like forward, but it preserves original sender info) Tag the message with a specific property value Permanently delete the message (Outlook doesn't use this when you create a rule with a delete action. Instead, it creates a MOVE action with the Deleted Items as the destination folder) Mark the message as read And finally, the big one: defer to the client to carry out client-defined actions. The asterisk on Move and Copy refers to what to do if the server can't reach the destination database. In this case, the server turns it into a defer to client action where it specifies to the client a) the move or copy action and b) the destination that should be used. As you can see, the server itself is pretty constrained on the kinds of things it can do, yet Outlook offers all these wonderful actions that can be carried out. This is accomplished via the deferred action. The client stores in the action any relevant data it needs and the server will later notify the client that it needs to carry out a deferred action on a message, and includes whatever the client stored in the rule (such as, perhaps, the WAV data for the sound to play, for example). Because a single rule could have conflicting actions, or even because multiple rules that may apply to the message could have conflicting actions, the server pulls off trickery to make sure everything happens correctly. For example, you may have two MOVE rules which apply to a message. You can't move a message to two different folders at once, yet that's the end result (the server treats subsequent MOVEs as if they were COPYs instead). Exchange Server rules are only executed during delivery. Outlook provides a Run Rules Now feature, but that's implemented entirely by Outlook. The server is not involved. Also, realize that server rules are not ever executed after delivery is complete. If you witness spontaneous changes happening to your inbox, this is either Outlook carrying out deferred actions, or someone else logged into your mailbox is changing things under your feet. What about the Junk Mail Rule? How does it adjust itself based on the administrator's configuration of the move action threshold? The administrator's configuration lives in Active Directory, so how could the rule dynamically retrieve this value for comparison against the Spam Confidence Level value stamped on all incoming messages? Well, there's a one-off cheat just for this. The rule itself is crafted to compare the Spam Confidence Level against the constant value -1. The rule execution engine pre-scans the restriction, looking for this specific comparison. If it finds it, it replaces the constant -1 with the current value in Active Directory, and then the restriction is applied to the incoming mail. You may be thinking: but what about two mailboxes, each with a reply rule that replies to the other mailbox? Won't that cause a mail storm? Well, ordinarily, yes. However, our rules engine is smarter than that. As a rule is triggered on a message, the rule's ID is stamped into an ever-growing property of I've already run this rule history. Therefore, if a message comes back , the rules engine can check to see if any particular rule is in this rule history and avoid running it again. So, if mbx1 sends mail to mbx2, which autoreplies back to mbx1, which autoreplies back to mbx2, the rules engine will detect the loop and not execute the rule that would otherwise cause another autoreply back to mbx1. - Dave Whitney Share this post :

It's about how stupid I am. Enough said.

Exchange 2007 Service Pack 1 introduces several changes in the Extensible Storage Engine (ESE). In my first blog article on the subject, I discussed the removal of page dependencies and the disabling of partial merges. In this blog, I discuss other changes we made to ESE which enhance Exchange. Passive Node I/O improvements Online Defragmentation Checksumming databases Page Zeroing Passive Node I/O Improvements When we released Exchange 2007, the I/O generated on the passive node in a CCR environment was ~2-3 times the I/O generated on the active node. For example, consider a server which contains 3500 very heavy profile mailboxes. The active node generated about 1300 IOPS, while the passive node generated about 3500 IOPS, even though the only activity occurring on the passive node is log inspection and replay! The extra I/O on the passive node was the result of the design of the replay function. In RTM, when log replay starts on the passive node, an instance of ESE is started and used to replay the replicated logs. During this replay activity, pages are read from the database, which in turn populates the ESE database cache. When log replay has finished, the Replication Services stops and discards the database instance, thereby deleting database cache that was built up during the replay process. As a result, we see spikes in activity. When log replay is not behind, the cache will continually be small, and thus more read I/Os will occur against the passive node's disks. When log replay gets behind, the instance of ESE will remain active longer, and we obtain a larger database cache, which decreases read I/Os. By itself, the additional disk I/O on the passive node is not a problem. But there are two scenarios where this additional I/O can have a significant impact - backups and storage design. Consider the scenario where you are performing VSS backups on the passive node. The additional disk I/O on the passive node can interfere with your ability to take a backup during the core user activity window, thus forcing you to schedule backups at off-hours. This negates the advantage of being able to backup storage groups on the passive node. The other scenario where the additional I/O is when storage is being shared. Consider these scenarios: You are sharing disk spindles with multiple mailbox servers. You are sharing the storage controller with multiple mailbox servers. In either case, you may have passive nodes mixed with active nodes. If you did not design the storage to handle this additional I/O that occurs on the passive node, the active node and the connecting end users could suffer. To improve performance in SP1, we changed this design of the system. In SP1, the Replication Service does not discard the database instance between replay batches. Instead, it simply pauses the instance until the next batch of logs is ready to be replayed. This change has several benefits. It: Allows the checkpoint to advance during recovery. Keeps the database cache "warm", which improves failover times. Allows the database cache to grow, which reduces read I/Os. Ensures there is no competing I/O that affects when you perform backups against the passive node. As a result of this change, we now see the passive node's I/O to be .5 to 1 times that of the active node! That is a huge reduction in I/O when compared to the passive node in RTM. Here's a graph of the aforementioned server with SP1. Online Defragmentation If you read my previous blog article on the ESE SP1 changes, you know that we reduced database churn significantly by disabling partial merges during online defragmentation (OLD). However, one other challenge remained - the challenge of determining how often you should run online defragmentation. Because Exchange had no metrics that could determine how often OLD should be run, our guidance always been to make sure that online defragmentation completes every week or every two weeks. Because each environment is different, this guidance was not optimal for every organization. We could not say with absolute certainty that completing OLD every week or every two weeks would be acceptable in every environment. Furthermore, there was always the question of how much time you should allocate to online maintenance. To address this in SP1, we added logic that allows you to determine how often you need to complete OLD. SP1 now includes new performance counters you can collection to determine this: MSExchangeDatabase - Online Defrag Pages Freed/sec MSExchangeDatabase - Online Defrag Pages Read/sec If you collect the values for these two counters you can determine how often you should perform OLD. If the Read:Freed ratio is greater than 100:1 then the OLD window can be reduced. If the Read:Freed ratio is less than 50:1 then the OLD window should be increased. If your ratio is between 50:1 and 100:1 you don't need to change your OLD window. In addition, we have added some information to event 703, which is logged when OLD successfully completes: Event Type: Information Event Source: ESE Event Category: Online Defragmentation Event ID: 703 Description: MSExchangeIS (19052) SG06: Online defragmentation has completed the resumed pass on database 'e:MDB06priv06.edb', freeing 42794 pages. This pass started on 6/16/2007 and ran for a total of 124919 seconds, requiring 7 invocations over 4 days. Since the database was created it has been fully defragmented 14 times over 73 days. The revised event now provides the following new information: When the OLD pass started. How many passes it took to complete. How many times the database has actually had OLD complete since database creation. This information can also be used to determine if you are completing OLD often enough. For example, if OLD is completing every day or two, you can safely reduce your online maintenance window. Why would you want to reduce your online maintenance window? Well, for one thing, you can increase your backup window (if you are performing backups on the active copy of a database). In addition, if you decrease your online maintenance window and you are performing VSS backups, this will reduce database churn and produce smaller snapshots or differential backups. Also, by reducing how often you perform online defragmentation, you will gain additional headroom during non-user activity periods so that you can perform database checksumming, which I discuss next. Database Checksumming With the release of Exchange 2007, we added a new feature called continuous replication. Continuous replication uses built-in asynchronous log shipping technology to create and maintain a copy of a storage group in a second location. In addition, continuous replication also allows you the freedom to change your backup paradigm. For example: You can utilize the streaming backup API to backup the active copy. You can utilize Volume Shadow Services (VSS) to backup the active copy. You can utilize VSS to backup the passive copy. Depending on the solution you use, one of the copies may never be checksummed, which is an important process in which the system compares the checksum written on each page of the database to the checksum that is calculated in memory. If the two match, then the page is good and no corruption has occurred. If they do not match, then there is a problem. Certain problems can be corrected (such as single bit errors), but others cannot and will require restoration (or reseed via a healthy copy). Streaming Backup of Active Copy The streaming backup API checksums each page of the database as it is backed up. This is typically where the system detects -1018s errors (and similar errors). Now consider the case where you have continuous replication in your environment. If you are performing a streaming backup, which database are you ensuring is healthy? That's right, the active copy. So while we know the status of the active copy, we do not know the status of the passive copy. So how can you ensure the health of your passive copy? Well there are few ways: Perform a handoff (CCR) or activate the passive copy (LCR) and then perform a backup. While this sounds easy, it is operationally a mess because you have to constantly perform handoffs / activations in order to check each copy. Utilize an Exchange-aware VSS requestor. We'll discuss the ramifications of this in a later section. Take a snapshot of the passive copy. For now, let's focus on #3. The process for performing a snapshot of the passive copy is relatively simple. You do not need an Exchange aware requestor to perform this. You can simply use the built-in Windows Server shadowcopy functionality to perform a snapshot. Here's the process: Suspend continuous replication for all storage groups hosted on the volume containing the databases to be checksummed. Use vssadmin.exe (which is included in Windows Server 2003) to create a shadow copy of the volume containing the databases to be checksummed. e.g. "vssadmin create shadow /for= volume " Resume continuous replication for all storage groups hosted on the volume. Run eseutil /k /p against the database(s) on the shadow copy of the volume) e.g. "eseutil /k /p20 Path for VSS Shadow Copy of Database " After verification has completed successfully, delete the volume shadow copy. E.g. "vssadmin delete shadow /For= volume " Essentially in this case you are performing an offline backup. You can then validate the integrity of the passive copy by verifying this offline backup. The one downside to this process is that there is a write performance penalty by performing the checksum since the snapshot is stored on the same LUN as the database (though remember that in SP1, the I/O requirements for the passive node are less or equal to the active node's I/O requirements). You will want to take the snapshot, perform the checksum, and then resume replication in a small time window, otherwise your log queue will grow, which while log replication will catch up once replication is resumed, there is still a chance that a failure could occur, and thus you'd have to deal with a lossy failure. VSS Backup of Active Copy In this scenario, a VSS based backup is taken against the active copy of the database. This scenario is very similar to the previously described scenario. The only difference is that VSS does not perform the checksum. Instead, the VSS requestor must either utilize ESEUTIL or CHKSGFILES.DLL (an API included in Exchange 2007 that allows requestors to programmatically request a checksum) to checksum the snapshot. Like the previous scenario, since the active copy is the one being backed up, the passive copy's health is in question. The same process I described previously can be used to check the health of the passive copy. Note: Though honestly, I don't know why you would be performing a VSS backup against the active copy when you could offload that process onto the passive copy. VSS Backup of Passive Copy This backup model is is very strongly recommended. Backing up a passive copy up allows you to offload the backup process (if using CCR the backup process occurs on passive node of the cluster, thereby removing backup cycles from the active instance all together). However this scenario also has a gap. If you are backing up the passive copy via VSS, then you will only know that the passive copy is healthy. You will not know if the active copy is healthy. This was a problem in RTM because the only way to determine the health of the active copy was to: perform a handoff/ activation and back it up perform a streaming copy backup perform an offline backup and utilize ESEUTIL To correct this in SP1, we have introduced a new online maintenance task, Online Maintenance Checksum. It is an optional task that is disabled by default, as it could affect server performance; however, it should be considered if you are performing backups against passive copies because it enables you to ensure that active copies are healthy. Online Maintenance Checksum utilizes half the online defragmentation time window to scan database pages. Like OLD, database scanning tracks its progress, with updates at regular intervals, so that it can continue where it left off when resuming after an interruption. Note: For those of you that may be wondering, there are many other tasks executed during the online maintenance window. For a listing of some of those other tasks, please see http://blogs.msdn.com/jeremyk/archive/2004/06/12/154283.aspx. Online defragmentation typically takes up the majority of the online maintenance window (the other tasks mentioned in the aforementioned blog complete relatively quickly; internally we typically see them complete within 15 minutes). If the Online Maintenance Checksum process determines that there is corruption, it will notify you via the application event log, utilizing the same events that are generated when you use the streaming backup API. The Online Maintenance Checksum task can perform very large sequential database reads (320KB). In addition, we have found that you obtain better performance if you stagger online maintenance so that only one database is checked per LUN. Also, in case there are other processes occurring during your online maintenance window, you have the ability to throttle the checksum process so that it only performs the sequential reads every x number of milliseconds. As you can see from the table below, there is a slight processor increase as a result of performing this operation. In addition, while this operation is occurring, you will also see about a 10% increase in RPC Average Latency. As a result, we do not recommend you perform this maintenance task during the peak user activity window. DB's Checksummed in Parallel DB Pages Read / s DB Read MB / s DB Read Latency (ms) % Processor 1 30000 250 3.5 7 2 8200 67 7.2 2.5 As you can see from the above table, when only performing the checksum operation against a single database on the LUN, you can achieve a whopping 250MB/s throughput. In MSIT, the majority of our databases complete Online Maintenance Checksum every night. Servers with our largest mailboxes (1GB + average) complete scanning once every three days (4 hours for Online Maintenance Checksum and 4 hours for OLD). To track the status of the Online Maintenance Checksum task, we have added several new events to the application log. Two events in particular notify you of status. Event 719 notifies you when the process begins, and event 721 notifies you when it completes. Here's an example of event 721: Event Type: Information Event Source: ESE Event Category: Online Defragmentation Event ID: 721 Description: MSExchangeIS (6584) Third Storage Group: Online Maintenance Database Checksumming background task has completed for database 'J:sg3priv3.edb'. This pass started on 6/19/2007 and ran for a total of 208 seconds, requiring 2 invocations over 1 days. Operation summary: 5850768 pages seen 0 bad checksums 72682 uninitialized pages In addition, we have added two new performance counters as well (which is how we obtained the data for the previous table): MSExchange Database - Online Maintenance (DB Scan) Pages Read MSExchange Database - Online Maintenance (DB Scan) Pages Read/sec The Online Maintenance Checksum task can be enabled via the registry: Registry Hive: HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesMSExchangeISParametersSystem DWORD Key: Online Maintenance Checksum DWORD Value: 1 (enabled), 0 (disabled) DWORD Key: Throttle Checksum DWORD Value: number of milliseconds to sleep between sequential read batches For more information, please see: http://technet.microsoft.com/en-us/library/bb676537.aspx Online Maintenance Checksum vs ESEUTIL There is a difference between the checksum process implemented in the Online Checksum task (streaming backup API or the online maintenance task) and the process used by ESEUTIL /K. Fundamentally, they both do the same thing in terms of how they check the pages. But there is a differencein their performance characteristics. The Online Checksum task uses a method known as JetDatabaseScan(). JetDatabaseScan() has a loop that issues a pre-read for 320KB of pages, scans the pages, and optionally sleeps. ESEUTIL /K, on the other hand, issues 1024 64KB read I/Os and when a read completes, the buffer is checksummed and another read is issued. Like the Online Checksum task, ESEUTIL can also optionally sleep for a configurable amount of time after issuing a certain number of reads. But the net difference here is that the Online Checksum task performs very well, and it is kinder on the disk subsystem than ESEUTIL. Page Zeroing Page Zeroing is a security option that allows empty pages to be overwritten using a pattern based on where the page sits within the B+ tree, so that deleted data cannot be recovered. With Exchange 2007 RTM and all previous versions, page zeroing operations happened during the streaming backup process. In addition since they occurred during the streaming backup process they were not a logged operation (e.g., page zeroing did not result in the generation of log files). This poses a problem in Exchange 2007 when you are using continuous replication, or when you are performing VSS backups. In the continuous replication scenario, the passive copy would never get its empty pages zeroed, and the active copy would only have its pages zeroed if you performed a streaming backup. In the VSS backup scenario, the database (active or passive copy) would never get its pages zeroed. To address these scenarios in SP1, we have introduced a new online maintenance task, Zero Database Pages During Checksum. It is an optional task that is disabled by default, as it could affect server performance. This is a logged operation that will get replicated to the passive copy, thereby ensuring that both database copies are updated. Online Page Zeroing, like the Online Maintenance Checksum task, performs large sequential reads (320KB), but is different from the Online Maintenance Checksum process in that it also generates random database writes (160KB). Fortunately, even if you enable both tasks, there is only a single database scan task in which both page zeroing and Online Maintenance Checksumming are done when either one is enabled (and incidentally, you have to enable the Online Maintenance Checksum task in order to enable Online Page Zeroing). This one task will retrieve the page from disk and perform both operations. As with Online Maintenance Checksumming, Online Page Zeroing performs better when you stagger online maintenance so that only one database is checked per LUN. However, there are a few things to keep in mind. When you initially enable Online Page Zeroing, the scan can place tremendous pressure on the database cache. To ensure this does not affect your server's performance, we recommend that you either implement the Throttle Checksum registry entry (mentioned in the previous section) or stagger your online maintenance window. Once the initial pass is completed, subsequent passes are much less intensive and will not impact the database cache significantly. Therefore, as a best practice, if you require page zeroing, consider enabling page zeroing on the database at creation time so that you will never have this first pass performance spike. Online Page Zeroing is very similar to a streaming backup (with page zeroing enabled). It reads from and writes to the database. Reads are sequential, but the writes are random. In addition, there is a slight processor use increase as a result, as well as about a 20% increase in RPC average latency while the database scan is occurring. As always, the best practice is to not execute online maintenance during the peak user activity window, and this is still true for the Online Page Zeroing task. DB's Page Zeroed in Parallel DB Pages Zeroed / s DB Read MB / s DB Write MB / s DB Read Latency (ms) % Processor 1 8100 68 66 3.4 7.5 2 6800 65 50 7.2 2.5 Remember that this task is a logged operation so watch your log capacity. Enabling the Online Page Zeroing task will utilize half of the OLD window (50% for Page Zeroing/Checksumming, 50% for OLD), so the logs generated by OLD per maintenance period will be roughly half of what they were without page zeroing enabled (assuming the same overall maintenance window). Page Zeroing does only log the page references that need to be zeroed and does not log the entire page (OLD writes do log the entire page in SP1). We pack anywhere from 2.5 K to 10 K zeroed page references per log. If the database cache is mostly clean, we ratchet up the number of page references/log; if the cache is mostly dirty, we ratchet down the number. The design ensures that page zeroing will not overwhelm the database cache (dirtying too much of the database cache) while reducing the number of logs generated (and subsequently replicated in continuous replication environments). Within MSIT we have page zeroing enabled on a servers with about 800 ~1GB mailboxes. On this server we do roughly the same amount of log generation during the page zeroing maintenance period as we do during the OLD period (1000 logs/hour). On servers that follow our memory guidance of 2-5MB/mailbox, as a result of the tighter packed logs for the page zeroing operations and the fact that the OLD window is reduced the log generation overhead of enabling page zeroing is more or less mitigated. The one scenario where log generation overhead becomes a factor is when the new tasks are enabled for the first time on an existing database. In this scenario, the log generation overhead can be 2-5x until the initial pass is finished. Afterwards, there should be no overhead. To track the status of the Online Page Zeroing task, we have added some new events to the application log. Two events in particular notify you of status. Event 718 notifies you when the process begins, and event 722 notifies you when it completes. Here's an example of event 722: Event Type: Information Event Source: ESE Event Category: Online Defragmentation Event ID: 722 Description: MSExchangeIS (6544) Third Storage Group: Online Maintenance Database Zeroing background task has completed for database 'J:sg3priv3.edb'. This pass started on 6/20/2007 and ran for a total of 369 seconds, requiring 1 invocations over 1 days. Operation summary: 5850768 pages seen 0 bad checksums 72681 uninitialized pages 4379723 pages unchanged since last zero 33759 unused pages zeroed 1210764 used pages seen 57214 deleted records zeroed 0 unreferenced data chunks zeroed In addition, we have added two new performance counters as well (which is how we obtained the data for the previous table): MSExchange Database - Online Maintenance (DB Scan) Pages Zeroed MSExchange Database - Online Maintenance (DB Scan) Pages Zeroed/sec The Online Page Zeroing task can be enabled via the registry. Please note that you have to enable the Online Maintenance Checksum task in order to enable the Online Page Zeroing task. Location: HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesMSExchangeISParametersSystem DWORD Key: Online Maintenance Checksum DWORD Value: 1 (enabled), 0 (disabled) DWORD Key: Zero Database Pages During Checksum DWORD Value: 1 (enabled), 0 (disabled) DWORD Key: Throttle Checksum DWORD Value: number of milliseconds to sleep between sequential read batches For more information, please see: http://technet.microsoft.com/en-us/library/bb676537.aspx Conclusion To summarize, SP1 enhances Microsoft Exchange manageability by allowing you to ensure that all databases are healthy, to measure when you should perform online defragmentation, and to ensure that page zeroing activity is replicated to each copy of every database. - Ross Smith IV Share this post :

Exchange 2007 Service Pack 1 introduces several changes in the Extensible Storage Engine (ESE). Two of these are: Removal of page dependencies Disablement of partial merges But first, in order to understand what is discussed below, we should have a brief discussion on ESE. ESE Architecture As you are well aware, operations that occur within Exchange are written to the transaction logs, changes are made to the database pages in memory, and then eventually those changes are flushed to the database file. Thus, ESE utilizes a transactional architecture; specifically ESE follows the ACID methodology. ACID is an acronym and means: Atomic - This means that a transaction state change is all or nothing. Consistent - This means that a transaction must preserve the consistency of the data (i.e. transforming it from one consistent state to the next). Isolated - This means that a transaction is a unit of operation and each assumes it is the only transaction occurring, even though multiple transactions occur at the same time. Durable - This means that committed transactions are preserved in the database, even if the system stops responding. The Extensible Storage Engine utilizes several components: Transaction Logs - Transaction log files record the operations that are performed against the database, to ensure durability in case of system failure. Checkpoint File - The checkpoint file is waypoint in the log sequence that indicates where in the log stream ESE needs to start a recovery in case of a failure. Checkpoint Depth - The checkpoint depth is a threshold that defines when ESE begins to aggressively flush dirty pages to the database. ESE Cache - An area of memory reserved to the Information Store process (Store.exe) that is used to store database pages in memory. By storing pages in memory, this can reduce read I/Os, especially when the page is accessed many times; in addition, this cache can be used in two ways to reduce write I/Os - by storing the dirty page in memory, there is the potential for multiple changes to be made to the page before it is flushed to disk; also, the engine can write multiple pages together (up to 1MB) using write coalescing. Log Buffers - Operations performed against the database are first held in memory before they are written to transaction logs. Version Store - An in-memory list of modifications that are made to the database. The version store is used for roll-back of transactions, for write-conflict detection, and for other tasks. The version store entry for a specific operation is cleaned up only one time when the following conditions are true: The transaction that owns the operation has been either committed or rolled back. All the transactions that are outstanding at the time that the operation was performed have been either committed or rolled back. EDB File - Exchange database (.edb) files are the repository for mailbox (or public folder) data. Within the database, data is stored in 8 KB database pages, which in turn are stored in a collection of balanced trees, known as B+ trees. A B+ tree, is a multi-level index where all records are stored in leaf nodes, which are logically linked together to allow efficient searching and sorting of data. This allows a B+ tree to promote a persistent arrangement of data and to be able to locate and retrieve information from the disk quickly. Note: For more information on B+ trees, please see http://en.wikipedia.org/wiki/B%2B_tree. So how do the above components work together? An operation occurs against the database (e.g. client sends a new message), and the page that requires updating is read from the file and placed into the ESE cache (if it is not already in memory), while the log buffer is notified and records the operation in memory. The changes are recorded by the database engine but are not immediately written to disk; instead, these changes are held in the ESE cache and are known as dirty pages because they have not been committed to the database. The version store is used to keep track of these changes, thus ensuring isolation and consistency are maintained. As the database pages are changed, the log buffer is notified to commit the change, and the transaction is recorded in a transaction log file (which may or may not require a log roll and a start of a new log generation). Eventually the dirty database pages are flushed to the database file. The checkpoint is advanced. For more information, please see Understanding the Exchange 2007 Store at http://technet.microsoft.com/en-us/library/bb331958.aspx. Page Dependencies Removal As an ESE database is updated, B+ tree splits and merges mean that records have to be moved from one location in the database to another. The easiest way to log the record move is to log a deletion ( record A was removed from page 13 ) and an insertion ( record A was inserted into page 14 ). The disadvantage of this approach is that the amount of data logged is proportional to the size of the records being moved. As the original insertion of the record ( record A was inserted into page 13 ) was logged it is redundant to re-log the same data. To overcome the issue of logging multiple copies of the data, ESE uses pages dependencies to reduce the amount of data that is logged during B+ tree splits or merges by forcing pages to be written to disk in a specific order. Instead of logging a deletion and an insertion we want to log a move operation ( record A was moved from page 13 to page 14 ). Suppose there is a crash after record A is moved from page 13 to page 14. If pages 13 and 14 can be flushed to disk independently then there are four possible states for pages 13 and 14 in the database: Page 13 Page 14 Recovery Action A blank Move A from 13 to 14 blank A Nothing - A has already been moved A A Delete A from page 13 blank blank Disaster - record A has been lost! In the last case, page 13 was written to disk after record A was removed but page 14 (which now contains record A) has not been written to disk. To avoid this happening a page dependency is created between pages 13 and 14 so that page 14 must be written to disk before page 13. This means that after a crash only the first three cases above are possible. What are the benefits to this approach? Page dependencies are a cunning way to reduce the amount of data logged when records are moved between pages in the database. If we only have to log the record's location when moving it, instead of the actual record itself, then we are reducing log generation, which ultimately reduces capacity requirements. But this poses several problems: Pages must be written to disk serially and the I/O cannot be coalesced. Not only does this have implications in terms of maintaining ACID, but it also has implications in terms of I/O. Each preceding page I/O must complete before the next one begins. It also means that if two (or more) consecutive pages have dependencies between them, they cannot be written in a single I/O. Multiple separate I/Os have to be performed serially. During streaming backup, page dependencies prevent some pages from being flushed to disk. Suppose record A is moved from page 13, which has not been backed up yet, to page 14 which has been backed up. The backed-up copy of page 14 doesn't contain the record so page 13 should not be written to disk (remember the logged operation only records the move, not the data moved). If page 13 was written, the backup would copy that image of page 13 and end up containing an image of page 13 without the record, making recovery impossible. Older versions of Exchange dealt with this problem by writing pages to the patch file, but the current version simply avoids flushing page 13 until the backup is finished. This in turn prevents the checkpoint from advancing, causing JET_errCheckpointDepthTooDeep problems if a backup job hangs. Recovering a single page cannot be done in isolation. At first glance restoring one page from a tape backup of an Exchange server looks easy - read the desired page from tape and then apply all the logged updates to that page. Unfortunately page dependencies make that impossible. Imagine a case where page 14 is being restored from tape and ESE encounters a logged update which says Move record A from page 13 to page 14 . Page 13 is now required to do the recovery - not the current version of page 13 (which doesn't contain record A) but an image of page 13 as it was at that point in time. This requires simultaneously restoring page 13 and page 14. In turn, page 13 might be the target of a record move so other pages will have to be restored as well. In general all the log files would have to be first restored and analyzed before single-page restore could be attempted. This would be incredibly complicated and require a lot of time and disk space, and is currently not something that can be done with Exchange 2007 (or any previous version). High memory requirements per storage group. During online defragmentation, ESE reorganizes the database structure, performing thousands of page merges and page splits in the attempt to free up pages. Remember that the data is not moved, we just reference the location. As a result, huge dependency trees are generated from the thousands upon thousands of operations that are performed during the maintenance cycle. This requires additional memory to hold all the dirty cache. To account for this, our RTM memory requirements were a minimum of 512 MB per storage group. So how can we address this situation? The simple answer is to remove page dependencies. Instead of creating page dependencies, we can simply log the entire source page when performing a record move or split. At recovery time, if the destination page has not flushed (e.g., it doesn't contain the data), but the source page has flushed (e.g., it doesn't contain the data either) the logged page image can be used to redo the data move. So what effect does removing page dependencies in Exchange 2007 SP1 have? By removing page dependencies we have improved database I/O characteristics. No longer do we have to write operations in a serial order since pages do not depend upon one another. This improves our database write I/O - we can now coalesce multiple writes together, thus reducing the number of I/Os, while increasing the write size. By removing page dependencies, we have reduced our minimum memory requirements per storage group. Now that we have removed page dependencies, we no longer generate large dependency trees during online defragmentation, and as a result, we have changed our memory guidance to require about 300MB per storage group. For more information on the minimum memory requirements, please take a look at http://technet.microsoft.com/en-us/library/bb738124.aspx. By removing page dependencies, we have massively reduced the likelihood of hitting the JET_errCheckpointDepthTooDeep condition associated with hung backups. Suppose record A is moved from page 13, which has not been backed up yet, to page 14, which has been backed up. The backed-up copy of page 14 doesn't contain the record, but since we logged page 13 to perform the move to page 14, we can flush the updated page 13 to disk. Even though the backup will only contain a copy of page 13 without the record, because the logs contain the actual data moved, we can now ensure that recovery can happen and not lose any data. As a result, the checkpoint can advance because the pages can be written to disk. Removing page dependencies means there are fewer dirty pages pinned in the cache which saves CPU resources and simplifies the job of the buffer manager. With page dependencies gone, the buffer manager can flush dirty pages when it sees fit, instead of having to walk the dependency tree to see if the flush can actually occur (in other words, we do not have to check to see if another page has to be written first due to page dependency). Walking the dependency tree is processor-expensive and gets even more expensive based on dependency tree depth (which is a function of the LLR waypoint depth). Removing page dependencies allows us to further evolve the product in ways that are particularly beneficial for continuous replication and reseed operations. Future versions (beyond Exchange 2007) may be able to take advantage of database page patching. However, removing page dependencies does have an impact. Page dependencies were originally conceived as a log optimization technique. By removing them, we now have to log the data being moved which means that log generations increase. Internally, we saw a 33% increase in log generation after we disabled page dependencies. The increase in log generation affects other things as well: Backup times. The more logs generated, the longer it will take to complete backups. Log capacity requirements. The more logs generated, the more capacity is required. Right now, many of you may be thinking Yikes, SP1 is going to pwn my log drives and since I didn't account for a 33% increase... darn you Exchange! Relax; we have you covered. Here's how we addressed this situation. Disabling Partial Merges While removing page dependencies provides us many benefits, the increase in log generation and the repercussions of this increase are not ideal. So we had to find a way to reduce log generation without breaking the ACID rules. To solve this issue, we went back and analyzed the logs generated on servers. After disabling page dependencies, what we found was that a significant portion of log generation increase is due to the automatic online defragmentation of the database. Online defragmentation (OLD) is a process used to free up pages in the EDB file. This reduces the number of pages that have to be visited in order to locate or insert data into the appropriate place. Essentially what happens is that the OLD process navigates to the end of a B+ tree and starts moving records from the left most pages to the right most pages, collapsing the B+ tree as much as possible. In many cases, the engine merges the records from one page to another without actually freeing a page; this is known as a partial merge. The hope here by doing partial merges, is that during the next OLD pass, the page will be able to be freed. Partial merges were useful back when disk sizes were very small (think back to Exchange 5.5 days), since it was important to utilize the capacity and I/O effectively to ensure that every last byte on the storage was used effectively to make the database as dense as possible. However, partial merges have consequences. As many probably have witnessed using Performance Monitor, OLD is an extremely disk write I/O intensive process. In addition, since we are moving data around within the database, the operations need to be logged, thus making OLD log generation intensive as well. The database churn that occurs during OLD also has another side affect that customers saw with the release of Exchange Server 2003 - snapshots via VSS are rather large due to the fact that a significant portion of the database changes each time OLD executes. So what would happen if we disabled partial merges? We disabled partial merges, and two things were found: 1. With partial merges disabled, databases are not compacted as tightly. With partial merges disabled, we will only move records from one page to another if we can free up the entire source page. As a result, there is some bloat to the database, however the bloat is small and does not increase drastically over time. For example, consider the following server that had a 162 GB and a 171 GB stores. A stress test was performed and we analyzed the difference between having partial merges enabled and disabled. The end result is that, after four weeks of having partial merges disabled, the database file only increased in size about 2%. 4 week stress test Partial Merges Enabled Partial Merges Disabled DB Size pre-defrag 162,588,409,856 171,188,961,280 % Available Pages 1.80% 1.33% DB Size Post-defrag 158,247,026,688 163,652,911,104 % Difference 2.65% 4.45% 2. With partial merges disabled, the database churn and log generation numbers significantly decrease when OLD runs. In the following example, you can see another comparison between two storage groups, one that has partial merges enabled and the other has partial merges disabled. On the storage group that had partial merges enabled, 20 GB of the database was manipulated due to partial merges and 18 thousand log files were generated. Whereas, on the storage group without partial merges, only 5 GB of the database changed and only 13 thousand log files were generated. That's a reduction in database churn of ~80% and a reduction of ~25% in log generation. 3000 Mailbox server (8hours) Partial Merges Enabled Partial Merges Disabled OLD Page Reads 56,160,000 57,830,400 OLD Pages Dirtied 3,830,400 691,200 OLD Pages Freed 392,457 201,600 BTree Partial Merges 2,494,080 0 Database Churn (GB) 30 5.5 Log Files Generated 18,269 13,701 In addition to OLD, we also found that partial merges were performed during normal runtime. Continuing with the 3000 mailbox server, we noticed that there was an average of 3 B+ tree partial merges/sec over a 24-hour period after we disabled partial merges in OLD. Each partial merge equated to roughly 3 page touches(dirtied), which over a 24 hour period resulted in 6000 logs being generated (the server generates around 110 thousand logs a day). By removing partial merges during normal runtime, we saw an additional 5% reduction in log generation. The benefit that partial merges provide in terms of database compactness is heavily outweighed by the cost to achieve that compactness (database churn and log generation). In the end, disabling partial merges netted us a reduction in log generation by 30% and substantially reduced our database churn during OLD. Log Generation Numbers & Message Profiles Even before we started coding SP1 we knew we were going to remove page dependencies. At the time we knew there would be a growth in log generation, and we didn't know how we would curb it. We assumed the worst case in that we would ship SP1 with a growth in log generation. So back in January of 2007, we released the storage calculator (http://go.microsoft.com/fwlink/?linkid=84202) and updated the storage design article (http://technet.microsoft.com/en-us/library/bb738147.aspx). One of the guidance changes included this table which associated log generation with the message profile: Mailbox profile Message profile Logs generated / mailbox / day Light 5 sent/20 received 7 Average 10 sent/40 received 14 Heavy 20 sent/80 received 28 Very heavy 30 sent/120 received 42 What we did not tell you at the time was that the values for the Logs generated / mailbox / day row included an increase for the page dependency removal. Now the good news is that since we disabled partial merges, the log generation growth experienced by removing page dependencies was canceled. As a result we are changing our log generation guidance to be as follows: Mailbox profile Message profile Logs generated / mailbox / day Light 5 sent/20 received 6 Average 10 sent/40 received 12 Heavy 20 sent/80 received 24 Very heavy 30 sent/120 received 36 Note: We will be updating the storage calculator and our storage guidance documentation on TechNet as a result. Conclusion To summarize, while disabling page dependencies included a 33% increase in log generation when compared with RTM, we were able to mitigate it by disabling partial merges. The end result is that we now have the following benefits: No more checkpoint too deep errors as a result of hung backups. Reduced memory requirements per storage group. Smaller snapshot / differential backups. A more efficient dirty page flushing model for the buffer manager, which improves write I/Os and reduces CPU cycles. Future versions of Exchange may be able to evolve recovery and/or reseed operations. Updated guidance on log generation numbers per message profile. - Ross Smith IV Share this post :

Some customers have experienced a problem where the following error is generated when installing the Mailbox role on an Exchange 2007 server (typically the first Exchange 2007 Mailbox server in the org): Exchange server address list service failed to respond You might also see events logged in the Application log of the server. For full symptom details, please see KB 935636. The above error is usually caused by setup failing to parse an LDAP filter properly. There are two types of LDAP filters we're aware of that cause this problem (and if someone has seen other filters - please let us know!). The first is a filter where an attribute name is immediately preceded by a logical operator: ( .CheckFilters The script is not signed, so you may need to adjust your execution policy using set-executionpolicy in order to allow it to run. The output will look like this: Evaluating: Default Policy Filter is good. Evaluating: Test Policy Filter is good. Evaluating: Default Global Address List Filter is good. If it finds a problem filter, it will tell you what problems it found on that filter: Evaluating: Lab2 Mailboxes Warning: a homeMDB value contains parentheses. Warning: an attribute name is immediately preceded by a logical operator. Hopefully this script will make it easier to identify the problem filters when setup fails, and since it can also be used to check for these problems ahead of time, you can get your filters fixed before you ever run setup, avoiding the problem entirely! To download the script itself, please go here. - Bill Long Share this post :

Number 8. It's about my gang and my chocolate bear. http://jerkbutt.blogspot.com

It's about hair cuts.Keep banging.

I'm done with critics. After this episode.

There is some confusion and misperceptions about the correct tools to use to manage a clustered mailbox server (CMS) in a single copy cluster (SCC) or cluster continuous replication (CCR) environment. Specifically, folks are asking the following questions: Do I use the Windows Server failover cluster management tools (namely, Cluster Administrator and Cluster.exe) to manage a CMS, or do you use the Exchange tools (namely, the Exchange Management Console and the Exchange Management Shell)? Will anything bad happen if I use the wrong tool to perform a task on my CMS? To clear up this confusion, I thought a blog post might be helpful. The answer to the second question is generally, no, because the answer to the first question is generally, there is no wrong tool. Instead, use of the tools really falls into two categories: You have to use tool X because there's no choice. This category refers to the tasks that must be per