swap_list.headはリスト内の最優先のデバイスで、 swap_list.nextに検索スタートのデバイスとなります。まだスワップを使用していないデフォルトではswap_list.head=swap_list.netxです。この値はswap_info[]のインデックスで、-1の時デバイスがありません。

type=swap_list.nextととし、swap_info[type]をチェック。type=swap_info[type].nextとし、プライオリティ順にデバイスを操作します。デバイスのスロットが取得できれば、続くデバイスのプライオリティが同じなら、swap_list.next=swap_info[type].nextとし、ラウンドロビンにデバイスを取得し、次のデバイスのプライオリティが違うなら(プライオリティが低い)、 swap_list.next = swap_list.headとし、プライオリティの一番高いヘッドからの走査となります。この時!wrapped &&とし、従って異なるプライオリティによる先頭からの再走査は最初の1回のみで、後はプライオリティに関係なくswap_info[type].nextと順に走査します。

si->highest_bitが0なら、デバイスのswap_info[]の空きがありません。空きがあるならscan_swap_map()で空きスロットを取得し、swp_entry(type, offset)でデバイスとスロットのインデックスをswp_entry_tとして返します。

ところで、最後のnext = swap_list.nextって意味あるのでしょうか？

swp_entry_t get_swap_page(void)
{
       struct swap_info_struct *si;
       pgoff_t offset;
       int type, next;
       int wrapped = 0;

       spin_lock(&swap_lock);
       if (nr_swap_pages <= 0)
               goto noswap;
       nr_swap_pages--;

       for (type = swap_list.next; type >= 0 && wrapped < 2; type = next) {
               si = swap_info[type];
               next = si->next;
               if (next < 0 ||
                   (!wrapped && si->prio != swap_info[next]->prio)) {
                       next = swap_list.head;
                       wrapped++;
               }

               if (!si->highest_bit)
                       continue;
               if (!(si->flags & SWP_WRITEOK))
                       continue;
               swap_list.next = next;
               offset = scan_swap_map(si, SWAP_HAS_CACHE);
               if (offset) {
                       spin_unlock(&swap_lock);
                       return swp_entry(type, offset);
               }
               next = swap_list.next;
       }

       nr_swap_pages++;
noswap:
       spin_unlock(&swap_lock);
       return (swp_entry_t) {0};
}

swp_entry()は、typeはswap_info[]のインデックス、offsetはそのデバイスのswap_map[]のインデックスをswp_entry_t ret.valに詰め込んだ物です。

static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
{
       swp_entry_t ret;

       ret.val = (type << SWP_TYPE_SHIFT(ret)) |
                       (offset & SWP_OFFSET_MASK(ret));
       return ret;
}

scan_swap_map()はデバイス内の空きスロットを検索します。swap_map[]内の0のインデックスを検索するのですが、物理的に連続するようにスロットを割り当てます。また運用上ランダムにスワップインされたりするため、フラグメントが発生します。それを避けるため、全swap_map[]として走査するのでなく、その内部を論理的なクラスタというブロックに分けて、その論理ブロック単位で割り当てていきます。この概念はext2/ext3ファイルシステムでも実装されていて、ext2/ext3のフラグメンテーションが発生しにくくなっている由縁です。

si->cluster_nrは論理的ブロックのクラスタ内の空きスロット(SWAPFILE_CLUSTER=256)です。0でなければこのクラスタ内から取得します。si->cluster_nextはクラスタ内での取得開始位置で、そこから順にswap_map[]の走査します。

si->highest_bitは空きスロットの最後尾インデックスです。si->cluster_nrでクラスタに空きがあるなら、si->cluster_nextから順に走査していきます。在ればgoto got_pageへ。無ければ改めてクラスタを割り当てます。

クラスタの割り当ては、空きスロットの先頭インデックスから最後尾まで、SWAPFILE_CLUSTER分あって、その全てのスロットが空きであることです。もしスロットが割り当てられなければ、最初から順に走査することになります。

文章でロジックを追うと返ってややこしくなるかと思います。イメージとしてはこんな感じで実装を見てもらった方がいいかと思います。まあ目的は空いているswap_map[]を取得する事にあるだけです。

static inline int scan_swap_map(struct swap_info_struct *si)
{
       unsigned long offset;

       if (si->cluster_nr) {
               while (si->cluster_next <= si->highest_bit) {
                       offset = si->cluster_next++;
                       if (si->swap_map[offset])
                               continue;
                       si->cluster_nr--;
                       goto got_page;
               }
       }
       si->cluster_nr = SWAPFILE_CLUSTER;

       offset = si->lowest_bit;
check_next_cluster:
       if (offset+SWAPFILE_CLUSTER-1 <= si->highest_bit)
       {
               int nr;
               for (nr = offset; nr < offset+SWAPFILE_CLUSTER; nr++) {
                       if (si->swap_map[nr])
                       {
                               offset = nr+1;
                               goto check_next_cluster;
                       }
               }
               goto got_page;
       }

       for (offset = si->lowest_bit; offset <= si->highest_bit ; offset++) {
               if (si->swap_map[offset])
                       continue;
               si->lowest_bit = offset+1;
       got_page:
               if (offset == si->lowest_bit)
                       si->lowest_bit++;
               if (offset == si->highest_bit)
                       si->highest_bit--;
               if (si->lowest_bit > si->highest_bit) {
                       si->lowest_bit = si->max;
                       si->highest_bit = 0;
               }
               si->swap_map[offset] = 1;
               si->inuse_pages++;
               nr_swap_pages--;
               si->cluster_next = offset+1;
               return offset;
       }
       si->lowest_bit = si->max;
       si->highest_bit = 0;
       return 0;
}

追記

自明のことですが、swapが発生する物理メモリの厳しい環境では、スワップ領域をUSBメモリに割り当てる事で、パフォーマンスの解消にるはずです。