Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * resize.c
0004  *
0005  * volume resize.
0006  * Inspired by ext3/resize.c.
0007  *
0008  * Copyright (C) 2007 Oracle.  All rights reserved.
0009  */
0010 
0011 #include <linux/fs.h>
0012 #include <linux/types.h>
0013 
0014 #include <cluster/masklog.h>
0015 
0016 #include "ocfs2.h"
0017 
0018 #include "alloc.h"
0019 #include "dlmglue.h"
0020 #include "inode.h"
0021 #include "journal.h"
0022 #include "super.h"
0023 #include "sysfile.h"
0024 #include "uptodate.h"
0025 #include "ocfs2_trace.h"
0026 
0027 #include "buffer_head_io.h"
0028 #include "suballoc.h"
0029 #include "resize.h"
0030 
0031 /*
0032  * Check whether there are new backup superblocks exist
0033  * in the last group. If there are some, mark them or clear
0034  * them in the bitmap.
0035  *
0036  * Return how many backups we find in the last group.
0037  */
0038 static u16 ocfs2_calc_new_backup_super(struct inode *inode,
0039                        struct ocfs2_group_desc *gd,
0040                        u16 cl_cpg,
0041                        u16 old_bg_clusters,
0042                        int set)
0043 {
0044     int i;
0045     u16 backups = 0;
0046     u32 cluster, lgd_cluster;
0047     u64 blkno, gd_blkno, lgd_blkno = le64_to_cpu(gd->bg_blkno);
0048 
0049     for (i = 0; i < OCFS2_MAX_BACKUP_SUPERBLOCKS; i++) {
0050         blkno = ocfs2_backup_super_blkno(inode->i_sb, i);
0051         cluster = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
0052 
0053         gd_blkno = ocfs2_which_cluster_group(inode, cluster);
0054         if (gd_blkno < lgd_blkno)
0055             continue;
0056         else if (gd_blkno > lgd_blkno)
0057             break;
0058 
0059         /* check if already done backup super */
0060         lgd_cluster = ocfs2_blocks_to_clusters(inode->i_sb, lgd_blkno);
0061         lgd_cluster += old_bg_clusters;
0062         if (lgd_cluster >= cluster)
0063             continue;
0064 
0065         if (set)
0066             ocfs2_set_bit(cluster % cl_cpg,
0067                       (unsigned long *)gd->bg_bitmap);
0068         else
0069             ocfs2_clear_bit(cluster % cl_cpg,
0070                     (unsigned long *)gd->bg_bitmap);
0071         backups++;
0072     }
0073 
0074     return backups;
0075 }
0076 
0077 static int ocfs2_update_last_group_and_inode(handle_t *handle,
0078                          struct inode *bm_inode,
0079                          struct buffer_head *bm_bh,
0080                          struct buffer_head *group_bh,
0081                          u32 first_new_cluster,
0082                          int new_clusters)
0083 {
0084     int ret = 0;
0085     struct ocfs2_super *osb = OCFS2_SB(bm_inode->i_sb);
0086     struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bm_bh->b_data;
0087     struct ocfs2_chain_list *cl = &fe->id2.i_chain;
0088     struct ocfs2_chain_rec *cr;
0089     struct ocfs2_group_desc *group;
0090     u16 chain, num_bits, backups = 0;
0091     u16 cl_bpc = le16_to_cpu(cl->cl_bpc);
0092     u16 cl_cpg = le16_to_cpu(cl->cl_cpg);
0093     u16 old_bg_clusters;
0094 
0095     trace_ocfs2_update_last_group_and_inode(new_clusters,
0096                         first_new_cluster);
0097 
0098     ret = ocfs2_journal_access_gd(handle, INODE_CACHE(bm_inode),
0099                       group_bh, OCFS2_JOURNAL_ACCESS_WRITE);
0100     if (ret < 0) {
0101         mlog_errno(ret);
0102         goto out;
0103     }
0104 
0105     group = (struct ocfs2_group_desc *)group_bh->b_data;
0106 
0107     old_bg_clusters = le16_to_cpu(group->bg_bits) / cl_bpc;
0108     /* update the group first. */
0109     num_bits = new_clusters * cl_bpc;
0110     le16_add_cpu(&group->bg_bits, num_bits);
0111     le16_add_cpu(&group->bg_free_bits_count, num_bits);
0112 
0113     /*
0114      * check whether there are some new backup superblocks exist in
0115      * this group and update the group bitmap accordingly.
0116      */
0117     if (OCFS2_HAS_COMPAT_FEATURE(osb->sb,
0118                      OCFS2_FEATURE_COMPAT_BACKUP_SB)) {
0119         backups = ocfs2_calc_new_backup_super(bm_inode,
0120                              group,
0121                              cl_cpg, old_bg_clusters, 1);
0122         le16_add_cpu(&group->bg_free_bits_count, -1 * backups);
0123     }
0124 
0125     ocfs2_journal_dirty(handle, group_bh);
0126 
0127     /* update the inode accordingly. */
0128     ret = ocfs2_journal_access_di(handle, INODE_CACHE(bm_inode), bm_bh,
0129                       OCFS2_JOURNAL_ACCESS_WRITE);
0130     if (ret < 0) {
0131         mlog_errno(ret);
0132         goto out_rollback;
0133     }
0134 
0135     chain = le16_to_cpu(group->bg_chain);
0136     cr = (&cl->cl_recs[chain]);
0137     le32_add_cpu(&cr->c_total, num_bits);
0138     le32_add_cpu(&cr->c_free, num_bits);
0139     le32_add_cpu(&fe->id1.bitmap1.i_total, num_bits);
0140     le32_add_cpu(&fe->i_clusters, new_clusters);
0141 
0142     if (backups) {
0143         le32_add_cpu(&cr->c_free, -1 * backups);
0144         le32_add_cpu(&fe->id1.bitmap1.i_used, backups);
0145     }
0146 
0147     spin_lock(&OCFS2_I(bm_inode)->ip_lock);
0148     OCFS2_I(bm_inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
0149     le64_add_cpu(&fe->i_size, (u64)new_clusters << osb->s_clustersize_bits);
0150     spin_unlock(&OCFS2_I(bm_inode)->ip_lock);
0151     i_size_write(bm_inode, le64_to_cpu(fe->i_size));
0152 
0153     ocfs2_journal_dirty(handle, bm_bh);
0154 
0155 out_rollback:
0156     if (ret < 0) {
0157         ocfs2_calc_new_backup_super(bm_inode,
0158                         group,
0159                         cl_cpg, old_bg_clusters, 0);
0160         le16_add_cpu(&group->bg_free_bits_count, backups);
0161         le16_add_cpu(&group->bg_bits, -1 * num_bits);
0162         le16_add_cpu(&group->bg_free_bits_count, -1 * num_bits);
0163     }
0164 out:
0165     if (ret)
0166         mlog_errno(ret);
0167     return ret;
0168 }
0169 
0170 static int update_backups(struct inode * inode, u32 clusters, char *data)
0171 {
0172     int i, ret = 0;
0173     u32 cluster;
0174     u64 blkno;
0175     struct buffer_head *backup = NULL;
0176     struct ocfs2_dinode *backup_di = NULL;
0177     struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
0178 
0179     /* calculate the real backups we need to update. */
0180     for (i = 0; i < OCFS2_MAX_BACKUP_SUPERBLOCKS; i++) {
0181         blkno = ocfs2_backup_super_blkno(inode->i_sb, i);
0182         cluster = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
0183         if (cluster >= clusters)
0184             break;
0185 
0186         ret = ocfs2_read_blocks_sync(osb, blkno, 1, &backup);
0187         if (ret < 0) {
0188             mlog_errno(ret);
0189             break;
0190         }
0191 
0192         memcpy(backup->b_data, data, inode->i_sb->s_blocksize);
0193 
0194         backup_di = (struct ocfs2_dinode *)backup->b_data;
0195         backup_di->i_blkno = cpu_to_le64(blkno);
0196 
0197         ret = ocfs2_write_super_or_backup(osb, backup);
0198         brelse(backup);
0199         backup = NULL;
0200         if (ret < 0) {
0201             mlog_errno(ret);
0202             break;
0203         }
0204     }
0205 
0206     return ret;
0207 }
0208 
0209 static void ocfs2_update_super_and_backups(struct inode *inode,
0210                        int new_clusters)
0211 {
0212     int ret;
0213     u32 clusters = 0;
0214     struct buffer_head *super_bh = NULL;
0215     struct ocfs2_dinode *super_di = NULL;
0216     struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
0217 
0218     /*
0219      * update the superblock last.
0220      * It doesn't matter if the write failed.
0221      */
0222     ret = ocfs2_read_blocks_sync(osb, OCFS2_SUPER_BLOCK_BLKNO, 1,
0223                      &super_bh);
0224     if (ret < 0) {
0225         mlog_errno(ret);
0226         goto out;
0227     }
0228 
0229     super_di = (struct ocfs2_dinode *)super_bh->b_data;
0230     le32_add_cpu(&super_di->i_clusters, new_clusters);
0231     clusters = le32_to_cpu(super_di->i_clusters);
0232 
0233     ret = ocfs2_write_super_or_backup(osb, super_bh);
0234     if (ret < 0) {
0235         mlog_errno(ret);
0236         goto out;
0237     }
0238 
0239     if (OCFS2_HAS_COMPAT_FEATURE(osb->sb, OCFS2_FEATURE_COMPAT_BACKUP_SB))
0240         ret = update_backups(inode, clusters, super_bh->b_data);
0241 
0242 out:
0243     brelse(super_bh);
0244     if (ret)
0245         printk(KERN_WARNING "ocfs2: Failed to update super blocks on %s"
0246             " during fs resize. This condition is not fatal,"
0247             " but fsck.ocfs2 should be run to fix it\n",
0248             osb->dev_str);
0249     return;
0250 }
0251 
0252 /*
0253  * Extend the filesystem to the new number of clusters specified.  This entry
0254  * point is only used to extend the current filesystem to the end of the last
0255  * existing group.
0256  */
0257 int ocfs2_group_extend(struct inode * inode, int new_clusters)
0258 {
0259     int ret;
0260     handle_t *handle;
0261     struct buffer_head *main_bm_bh = NULL;
0262     struct buffer_head *group_bh = NULL;
0263     struct inode *main_bm_inode = NULL;
0264     struct ocfs2_dinode *fe = NULL;
0265     struct ocfs2_group_desc *group = NULL;
0266     struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
0267     u16 cl_bpc;
0268     u32 first_new_cluster;
0269     u64 lgd_blkno;
0270 
0271     if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
0272         return -EROFS;
0273 
0274     if (new_clusters < 0)
0275         return -EINVAL;
0276     else if (new_clusters == 0)
0277         return 0;
0278 
0279     main_bm_inode = ocfs2_get_system_file_inode(osb,
0280                             GLOBAL_BITMAP_SYSTEM_INODE,
0281                             OCFS2_INVALID_SLOT);
0282     if (!main_bm_inode) {
0283         ret = -EINVAL;
0284         mlog_errno(ret);
0285         goto out;
0286     }
0287 
0288     inode_lock(main_bm_inode);
0289 
0290     ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
0291     if (ret < 0) {
0292         mlog_errno(ret);
0293         goto out_mutex;
0294     }
0295 
0296     fe = (struct ocfs2_dinode *)main_bm_bh->b_data;
0297 
0298     /* main_bm_bh is validated by inode read inside ocfs2_inode_lock(),
0299      * so any corruption is a code bug. */
0300     BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
0301 
0302     if (le16_to_cpu(fe->id2.i_chain.cl_cpg) !=
0303         ocfs2_group_bitmap_size(osb->sb, 0,
0304                     osb->s_feature_incompat) * 8) {
0305         mlog(ML_ERROR, "The disk is too old and small. "
0306              "Force to do offline resize.");
0307         ret = -EINVAL;
0308         goto out_unlock;
0309     }
0310 
0311     first_new_cluster = le32_to_cpu(fe->i_clusters);
0312     lgd_blkno = ocfs2_which_cluster_group(main_bm_inode,
0313                           first_new_cluster - 1);
0314 
0315     ret = ocfs2_read_group_descriptor(main_bm_inode, fe, lgd_blkno,
0316                       &group_bh);
0317     if (ret < 0) {
0318         mlog_errno(ret);
0319         goto out_unlock;
0320     }
0321     group = (struct ocfs2_group_desc *)group_bh->b_data;
0322 
0323     cl_bpc = le16_to_cpu(fe->id2.i_chain.cl_bpc);
0324     if (le16_to_cpu(group->bg_bits) / cl_bpc + new_clusters >
0325         le16_to_cpu(fe->id2.i_chain.cl_cpg)) {
0326         ret = -EINVAL;
0327         goto out_unlock;
0328     }
0329 
0330 
0331     trace_ocfs2_group_extend(
0332          (unsigned long long)le64_to_cpu(group->bg_blkno), new_clusters);
0333 
0334     handle = ocfs2_start_trans(osb, OCFS2_GROUP_EXTEND_CREDITS);
0335     if (IS_ERR(handle)) {
0336         mlog_errno(PTR_ERR(handle));
0337         ret = -EINVAL;
0338         goto out_unlock;
0339     }
0340 
0341     /* update the last group descriptor and inode. */
0342     ret = ocfs2_update_last_group_and_inode(handle, main_bm_inode,
0343                         main_bm_bh, group_bh,
0344                         first_new_cluster,
0345                         new_clusters);
0346     if (ret) {
0347         mlog_errno(ret);
0348         goto out_commit;
0349     }
0350 
0351     ocfs2_update_super_and_backups(main_bm_inode, new_clusters);
0352 
0353 out_commit:
0354     ocfs2_commit_trans(osb, handle);
0355 out_unlock:
0356     brelse(group_bh);
0357     brelse(main_bm_bh);
0358 
0359     ocfs2_inode_unlock(main_bm_inode, 1);
0360 
0361 out_mutex:
0362     inode_unlock(main_bm_inode);
0363     iput(main_bm_inode);
0364 
0365 out:
0366     return ret;
0367 }
0368 
0369 static int ocfs2_check_new_group(struct inode *inode,
0370                  struct ocfs2_dinode *di,
0371                  struct ocfs2_new_group_input *input,
0372                  struct buffer_head *group_bh)
0373 {
0374     int ret;
0375     struct ocfs2_group_desc *gd =
0376         (struct ocfs2_group_desc *)group_bh->b_data;
0377     u16 cl_bpc = le16_to_cpu(di->id2.i_chain.cl_bpc);
0378 
0379     ret = ocfs2_check_group_descriptor(inode->i_sb, di, group_bh);
0380     if (ret)
0381         goto out;
0382 
0383     ret = -EINVAL;
0384     if (le16_to_cpu(gd->bg_chain) != input->chain)
0385         mlog(ML_ERROR, "Group descriptor # %llu has bad chain %u "
0386              "while input has %u set.\n",
0387              (unsigned long long)le64_to_cpu(gd->bg_blkno),
0388              le16_to_cpu(gd->bg_chain), input->chain);
0389     else if (le16_to_cpu(gd->bg_bits) != input->clusters * cl_bpc)
0390         mlog(ML_ERROR, "Group descriptor # %llu has bit count %u but "
0391              "input has %u clusters set\n",
0392              (unsigned long long)le64_to_cpu(gd->bg_blkno),
0393              le16_to_cpu(gd->bg_bits), input->clusters);
0394     else if (le16_to_cpu(gd->bg_free_bits_count) != input->frees * cl_bpc)
0395         mlog(ML_ERROR, "Group descriptor # %llu has free bit count %u "
0396              "but it should have %u set\n",
0397              (unsigned long long)le64_to_cpu(gd->bg_blkno),
0398              le16_to_cpu(gd->bg_bits),
0399              input->frees * cl_bpc);
0400     else
0401         ret = 0;
0402 
0403 out:
0404     return ret;
0405 }
0406 
0407 static int ocfs2_verify_group_and_input(struct inode *inode,
0408                     struct ocfs2_dinode *di,
0409                     struct ocfs2_new_group_input *input,
0410                     struct buffer_head *group_bh)
0411 {
0412     u16 cl_count = le16_to_cpu(di->id2.i_chain.cl_count);
0413     u16 cl_cpg = le16_to_cpu(di->id2.i_chain.cl_cpg);
0414     u16 next_free = le16_to_cpu(di->id2.i_chain.cl_next_free_rec);
0415     u32 cluster = ocfs2_blocks_to_clusters(inode->i_sb, input->group);
0416     u32 total_clusters = le32_to_cpu(di->i_clusters);
0417     int ret = -EINVAL;
0418 
0419     if (cluster < total_clusters)
0420         mlog(ML_ERROR, "add a group which is in the current volume.\n");
0421     else if (input->chain >= cl_count)
0422         mlog(ML_ERROR, "input chain exceeds the limit.\n");
0423     else if (next_free != cl_count && next_free != input->chain)
0424         mlog(ML_ERROR,
0425              "the add group should be in chain %u\n", next_free);
0426     else if (total_clusters + input->clusters < total_clusters)
0427         mlog(ML_ERROR, "add group's clusters overflow.\n");
0428     else if (input->clusters > cl_cpg)
0429         mlog(ML_ERROR, "the cluster exceeds the maximum of a group\n");
0430     else if (input->frees > input->clusters)
0431         mlog(ML_ERROR, "the free cluster exceeds the total clusters\n");
0432     else if (total_clusters % cl_cpg != 0)
0433         mlog(ML_ERROR,
0434              "the last group isn't full. Use group extend first.\n");
0435     else if (input->group != ocfs2_which_cluster_group(inode, cluster))
0436         mlog(ML_ERROR, "group blkno is invalid\n");
0437     else if ((ret = ocfs2_check_new_group(inode, di, input, group_bh)))
0438         mlog(ML_ERROR, "group descriptor check failed.\n");
0439     else
0440         ret = 0;
0441 
0442     return ret;
0443 }
0444 
0445 /* Add a new group descriptor to global_bitmap. */
0446 int ocfs2_group_add(struct inode *inode, struct ocfs2_new_group_input *input)
0447 {
0448     int ret;
0449     handle_t *handle;
0450     struct buffer_head *main_bm_bh = NULL;
0451     struct inode *main_bm_inode = NULL;
0452     struct ocfs2_dinode *fe = NULL;
0453     struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
0454     struct buffer_head *group_bh = NULL;
0455     struct ocfs2_group_desc *group = NULL;
0456     struct ocfs2_chain_list *cl;
0457     struct ocfs2_chain_rec *cr;
0458     u16 cl_bpc;
0459     u64 bg_ptr;
0460 
0461     if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
0462         return -EROFS;
0463 
0464     main_bm_inode = ocfs2_get_system_file_inode(osb,
0465                             GLOBAL_BITMAP_SYSTEM_INODE,
0466                             OCFS2_INVALID_SLOT);
0467     if (!main_bm_inode) {
0468         ret = -EINVAL;
0469         mlog_errno(ret);
0470         goto out;
0471     }
0472 
0473     inode_lock(main_bm_inode);
0474 
0475     ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
0476     if (ret < 0) {
0477         mlog_errno(ret);
0478         goto out_mutex;
0479     }
0480 
0481     fe = (struct ocfs2_dinode *)main_bm_bh->b_data;
0482 
0483     if (le16_to_cpu(fe->id2.i_chain.cl_cpg) !=
0484         ocfs2_group_bitmap_size(osb->sb, 0,
0485                     osb->s_feature_incompat) * 8) {
0486         mlog(ML_ERROR, "The disk is too old and small."
0487              " Force to do offline resize.");
0488         ret = -EINVAL;
0489         goto out_unlock;
0490     }
0491 
0492     ret = ocfs2_read_blocks_sync(osb, input->group, 1, &group_bh);
0493     if (ret < 0) {
0494         mlog(ML_ERROR, "Can't read the group descriptor # %llu "
0495              "from the device.", (unsigned long long)input->group);
0496         goto out_unlock;
0497     }
0498 
0499     ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), group_bh);
0500 
0501     ret = ocfs2_verify_group_and_input(main_bm_inode, fe, input, group_bh);
0502     if (ret) {
0503         mlog_errno(ret);
0504         goto out_free_group_bh;
0505     }
0506 
0507     trace_ocfs2_group_add((unsigned long long)input->group,
0508                    input->chain, input->clusters, input->frees);
0509 
0510     handle = ocfs2_start_trans(osb, OCFS2_GROUP_ADD_CREDITS);
0511     if (IS_ERR(handle)) {
0512         mlog_errno(PTR_ERR(handle));
0513         ret = -EINVAL;
0514         goto out_free_group_bh;
0515     }
0516 
0517     cl_bpc = le16_to_cpu(fe->id2.i_chain.cl_bpc);
0518     cl = &fe->id2.i_chain;
0519     cr = &cl->cl_recs[input->chain];
0520 
0521     ret = ocfs2_journal_access_gd(handle, INODE_CACHE(main_bm_inode),
0522                       group_bh, OCFS2_JOURNAL_ACCESS_WRITE);
0523     if (ret < 0) {
0524         mlog_errno(ret);
0525         goto out_commit;
0526     }
0527 
0528     group = (struct ocfs2_group_desc *)group_bh->b_data;
0529     bg_ptr = le64_to_cpu(group->bg_next_group);
0530     group->bg_next_group = cr->c_blkno;
0531     ocfs2_journal_dirty(handle, group_bh);
0532 
0533     ret = ocfs2_journal_access_di(handle, INODE_CACHE(main_bm_inode),
0534                       main_bm_bh, OCFS2_JOURNAL_ACCESS_WRITE);
0535     if (ret < 0) {
0536         group->bg_next_group = cpu_to_le64(bg_ptr);
0537         mlog_errno(ret);
0538         goto out_commit;
0539     }
0540 
0541     if (input->chain == le16_to_cpu(cl->cl_next_free_rec)) {
0542         le16_add_cpu(&cl->cl_next_free_rec, 1);
0543         memset(cr, 0, sizeof(struct ocfs2_chain_rec));
0544     }
0545 
0546     cr->c_blkno = cpu_to_le64(input->group);
0547     le32_add_cpu(&cr->c_total, input->clusters * cl_bpc);
0548     le32_add_cpu(&cr->c_free, input->frees * cl_bpc);
0549 
0550     le32_add_cpu(&fe->id1.bitmap1.i_total, input->clusters *cl_bpc);
0551     le32_add_cpu(&fe->id1.bitmap1.i_used,
0552              (input->clusters - input->frees) * cl_bpc);
0553     le32_add_cpu(&fe->i_clusters, input->clusters);
0554 
0555     ocfs2_journal_dirty(handle, main_bm_bh);
0556 
0557     spin_lock(&OCFS2_I(main_bm_inode)->ip_lock);
0558     OCFS2_I(main_bm_inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
0559     le64_add_cpu(&fe->i_size, (u64)input->clusters << osb->s_clustersize_bits);
0560     spin_unlock(&OCFS2_I(main_bm_inode)->ip_lock);
0561     i_size_write(main_bm_inode, le64_to_cpu(fe->i_size));
0562 
0563     ocfs2_update_super_and_backups(main_bm_inode, input->clusters);
0564 
0565 out_commit:
0566     ocfs2_commit_trans(osb, handle);
0567 
0568 out_free_group_bh:
0569     brelse(group_bh);
0570 
0571 out_unlock:
0572     brelse(main_bm_bh);
0573 
0574     ocfs2_inode_unlock(main_bm_inode, 1);
0575 
0576 out_mutex:
0577     inode_unlock(main_bm_inode);
0578     iput(main_bm_inode);
0579 
0580 out:
0581     return ret;
0582 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!