开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
lvm-snap.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

lvm-snap.c：源码内容
  1. /*
  2.  * kernel/lvm-snap.c
  3.  *
  4.  * Copyright (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE
  5.  *                    Heinz Mauelshagen, Sistina Software (persistent snapshots)
  6.  *
  7.  * LVM snapshot driver is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2, or (at your option)
  10.  * any later version.
  11.  * 
  12.  * LVM snapshot driver is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  * 
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with GNU CC; see the file COPYING.  If not, write to
  19.  * the Free Software Foundation, 59 Temple Place - Suite 330,
  20.  * Boston, MA 02111-1307, USA. 
  21.  *
  22.  */
  24. /*
  25.  * Changelog
  26.  *
  27.  *    05/07/2000 - implemented persistent snapshot support
  28.  *    23/11/2000 - used cpu_to_le64 rather than my own macro
  29.  *    25/01/2001 - Put LockPage back in
  30.  *    01/02/2001 - A dropped snapshot is now set as inactive
  31.  *    12/03/2001 - lvm_pv_get_number changes:
  32.  *                 o made it static
  33.  *                 o renamed it to _pv_get_number
  34.  *                 o pv number is returned in new uint * arg
  35.  *                 o -1 returned on error
  36.  *                 lvm_snapshot_fill_COW_table has a return value too.
  37.  *
  38.  */
  40. #include <linux/kernel.h>
  41. #include <linux/module.h>
  42. #include <linux/vmalloc.h>
  43. #include <linux/blkdev.h>
  44. #include <linux/smp_lock.h>
  45. #include <linux/types.h>
  46. #include <linux/iobuf.h>
  47. #include <linux/lvm.h>
  50. #include "lvm-internal.h"
  52. static char *lvm_snap_version __attribute__ ((unused)) =
  53.    "LVM "LVM_RELEASE_NAME" snapshot code ("LVM_RELEASE_DATE")n";
  56. extern const char *const lvm_name;
  57. extern int lvm_blocksizes[];
  59. void lvm_snapshot_release(lv_t *);
  60. static int _write_COW_table_block(vg_t *vg, lv_t *lv, int idx,
  61.                                  const char **reason);
  62. static void _disable_snapshot(vg_t *vg, lv_t *lv);
  65. static int _pv_get_number(vg_t * vg, kdev_t rdev, uint *pvn) {
  66. uint p;
  67. for(p = 0; p < vg->pv_max; p++) {
  68. if(vg->pv[p] == NULL)
  69. continue;
  71. if(vg->pv[p]->pv_dev == rdev)
  72. break;
  74. }
  76.   if(p >= vg->pv_max) {
  77. /* bad news, the snapshot COW table is probably corrupt */
  78. printk(KERN_ERR
  79.        "%s -- _pv_get_number failed for rdev = %un",
  80.        lvm_name, rdev);
  81. return -1;
  82. }
  84. *pvn = vg->pv[p]->pv_number;
  85. return 0;
  86. }
  88. #define hashfn(dev,block,mask,chunk_size) 
  89. ((HASHDEV(dev)^((block)/(chunk_size))) & (mask))
  91. static inline lv_block_exception_t *
  92. lvm_find_exception_table(kdev_t org_dev, unsigned long org_start, lv_t * lv)
  93. {
  94. struct list_head * hash_table = lv->lv_snapshot_hash_table, * next;
  95. unsigned long mask = lv->lv_snapshot_hash_mask;
  96. int chunk_size = lv->lv_chunk_size;
  97. lv_block_exception_t * ret;
  98. int i = 0;
  100. hash_table = &hash_table[hashfn(org_dev, org_start, mask, chunk_size)];
  101. ret = NULL;
  102. for (next = hash_table->next; next != hash_table; next = next->next)
  103. {
  104. lv_block_exception_t * exception;
  106. exception = list_entry(next, lv_block_exception_t, hash);
  107. if (exception->rsector_org == org_start &&
  108.     exception->rdev_org == org_dev)
  109. {
  110. if (i)
  111. {
  112. /* fun, isn't it? :) */
  113. list_del(next);
  114. list_add(next, hash_table);
  115. }
  116. ret = exception;
  117. break;
  118. }
  119. i++;
  120. }
  121. return ret;
  122. }
  124. inline void lvm_hash_link(lv_block_exception_t * exception,
  125.   kdev_t org_dev, unsigned long org_start,
  126.   lv_t * lv)
  127. {
  128. struct list_head * hash_table = lv->lv_snapshot_hash_table;
  129. unsigned long mask = lv->lv_snapshot_hash_mask;
  130. int chunk_size = lv->lv_chunk_size;
  132. hash_table = &hash_table[hashfn(org_dev, org_start, mask, chunk_size)];
  133. list_add(&exception->hash, hash_table);
  134. }
  136. int lvm_snapshot_remap_block(kdev_t * org_dev, unsigned long * org_sector,
  137.      unsigned long pe_start, lv_t * lv)
  138. {
  139. int ret;
  140. unsigned long pe_off, pe_adjustment, __org_start;
  141. kdev_t __org_dev;
  142. int chunk_size = lv->lv_chunk_size;
  143. lv_block_exception_t * exception;
  145. pe_off = pe_start % chunk_size;
  146. pe_adjustment = (*org_sector-pe_off) % chunk_size;
  147. __org_start = *org_sector - pe_adjustment;
  148. __org_dev = *org_dev;
  149. ret = 0;
  150. exception = lvm_find_exception_table(__org_dev, __org_start, lv);
  151. if (exception)
  152. {
  153. *org_dev = exception->rdev_new;
  154. *org_sector = exception->rsector_new + pe_adjustment;
  155. ret = 1;
  156. }
  157. return ret;
  158. }
  160. void lvm_drop_snapshot(vg_t *vg, lv_t *lv_snap, const char *reason)
  161. {
  162. kdev_t last_dev;
  163. int i;
  165. /* no exception storage space available for this snapshot
  166.    or error on this snapshot --> release it */
  167. invalidate_buffers(lv_snap->lv_dev);
  169.        /* wipe the snapshot since it's inconsistent now */
  170.        _disable_snapshot(vg, lv_snap);
  172. for (i = last_dev = 0; i < lv_snap->lv_remap_ptr; i++) {
  173. if ( lv_snap->lv_block_exception[i].rdev_new != last_dev) {
  174. last_dev = lv_snap->lv_block_exception[i].rdev_new;
  175. invalidate_buffers(last_dev);
  176. }
  177. }
  179. lvm_snapshot_release(lv_snap);
  180. lv_snap->lv_status &= ~LV_ACTIVE;
  182. printk(KERN_INFO
  183.        "%s -- giving up to snapshot %s on %s: %sn",
  184.        lvm_name, lv_snap->lv_snapshot_org->lv_name, lv_snap->lv_name,
  185.        reason);
  186. }
  188. static inline int lvm_snapshot_prepare_blocks(unsigned long *blocks,
  189.       unsigned long start,
  190.       int nr_sectors,
  191.       int blocksize)
  192. {
  193. int i, sectors_per_block, nr_blocks;
  195. sectors_per_block = blocksize / SECTOR_SIZE;
  197. if(start & (sectors_per_block - 1))
  198. return 0;
  200. nr_blocks = nr_sectors / sectors_per_block;
  201. start /= sectors_per_block;
  203. for (i = 0; i < nr_blocks; i++)
  204. blocks[i] = start++;
  206. return 1;
  207. }
  209. inline int lvm_get_blksize(kdev_t dev)
  210. {
  211. int correct_size = BLOCK_SIZE, i, major;
  213. major = MAJOR(dev);
  214. if (blksize_size[major])
  215. {
  216. i = blksize_size[major][MINOR(dev)];
  217. if (i)
  218. correct_size = i;
  219. }
  220. return correct_size;
  221. }
  223. #ifdef DEBUG_SNAPSHOT
  224. static inline void invalidate_snap_cache(unsigned long start, unsigned long nr,
  225.  kdev_t dev)
  226. {
  227. struct buffer_head * bh;
  228. int sectors_per_block, i, blksize, minor;
  230. minor = MINOR(dev);
  231. blksize = lvm_blocksizes[minor];
  232. sectors_per_block = blksize >> 9;
  233. nr /= sectors_per_block;
  234. start /= sectors_per_block;
  236. for (i = 0; i < nr; i++)
  237. {
  238. bh = get_hash_table(dev, start++, blksize);
  239. if (bh)
  240. bforget(bh);
  241. }
  242. }
  243. #endif
  246. int lvm_snapshot_fill_COW_page(vg_t * vg, lv_t * lv_snap)
  247. {
  248.        uint pvn;
  249.        int id = 0, is = lv_snap->lv_remap_ptr;
  250.        ulong blksize_snap;
  251.        lv_COW_table_disk_t * lv_COW_table = (lv_COW_table_disk_t *)
  252.                page_address(lv_snap->lv_COW_table_iobuf->maplist[0]);
  254.        if (is == 0)
  255.                return 0;
  257. is--;
  258.         blksize_snap =
  259.                lvm_get_blksize(lv_snap->lv_block_exception[is].rdev_new);
  260.         is -= is % (blksize_snap / sizeof(lv_COW_table_disk_t));
  262. memset(lv_COW_table, 0, blksize_snap);
  263. for ( ; is < lv_snap->lv_remap_ptr; is++, id++) {
  264. /* store new COW_table entry */
  265.                lv_block_exception_t *be = lv_snap->lv_block_exception + is;
  266.                if(_pv_get_number(vg, be->rdev_org, &pvn))
  267.                        goto bad;
  269.                lv_COW_table[id].pv_org_number = cpu_to_le64(pvn);
  270.                lv_COW_table[id].pv_org_rsector = cpu_to_le64(be->rsector_org);
  271.                if(_pv_get_number(vg, be->rdev_new, &pvn))
  272.                        goto bad;
  274.                lv_COW_table[id].pv_snap_number = cpu_to_le64(pvn);
  275.                lv_COW_table[id].pv_snap_rsector =
  276.                        cpu_to_le64(be->rsector_new);
  277. }
  279.        return 0;
  281.  bad:
  282.        printk(KERN_ERR "%s -- lvm_snapshot_fill_COW_page failed", lvm_name);
  283.        return -1;
  284. }
  287. /*
  288.  * writes a COW exception table sector to disk (HM)
  289.  */
  291. int lvm_write_COW_table_block(vg_t * vg, lv_t *lv_snap)
  292. {
  293. int r;
  294. const char *err;
  295. if((r = _write_COW_table_block(vg, lv_snap,
  296.        lv_snap->lv_remap_ptr - 1, &err)))
  297. lvm_drop_snapshot(vg, lv_snap, err);
  298. return r;
  299. }
  301. /*
  302.  * copy on write handler for one snapshot logical volume
  303.  *
  304.  * read the original blocks and store it/them on the new one(s).
  305.  * if there is no exception storage space free any longer --> release snapshot.
  306.  *
  307.  * this routine gets called for each _first_ write to a physical chunk.
  308.  */
  309. int lvm_snapshot_COW(kdev_t org_phys_dev,
  310.      unsigned long org_phys_sector,
  311.      unsigned long org_pe_start,
  312.      unsigned long org_virt_sector,
  313.      vg_t *vg, lv_t* lv_snap)
  314. {
  315. const char * reason;
  316. unsigned long org_start, snap_start, snap_phys_dev, virt_start, pe_off;
  317. int idx = lv_snap->lv_remap_ptr, chunk_size = lv_snap->lv_chunk_size;
  318. struct kiobuf * iobuf;
  319. int blksize_snap, blksize_org, min_blksize, max_blksize;
  320. int max_sectors, nr_sectors;
  322. /* check if we are out of snapshot space */
  323. if (idx >= lv_snap->lv_remap_end)
  324. goto fail_out_of_space;
  326. /* calculate physical boundaries of source chunk */
  327. pe_off = org_pe_start % chunk_size;
  328. org_start = org_phys_sector - ((org_phys_sector-pe_off) % chunk_size);
  329. virt_start = org_virt_sector - (org_phys_sector - org_start);
  331. /* calculate physical boundaries of destination chunk */
  332. snap_phys_dev = lv_snap->lv_block_exception[idx].rdev_new;
  333. snap_start = lv_snap->lv_block_exception[idx].rsector_new;
  335. #ifdef DEBUG_SNAPSHOT
  336. printk(KERN_INFO
  337.        "%s -- COW: "
  338.        "org %s faulting %lu start %lu, snap %s start %lu, "
  339.        "size %d, pe_start %lu pe_off %lu, virt_sec %lun",
  340.        lvm_name,
  341.        kdevname(org_phys_dev), org_phys_sector, org_start,
  342.        kdevname(snap_phys_dev), snap_start,
  343.        chunk_size,
  344.        org_pe_start, pe_off,
  345.        org_virt_sector);
  346. #endif
  348. iobuf = lv_snap->lv_iobuf;
  350. blksize_org = lvm_get_blksize(org_phys_dev);
  351. blksize_snap = lvm_get_blksize(snap_phys_dev);
  352. max_blksize = max(blksize_org, blksize_snap);
  353. min_blksize = min(blksize_org, blksize_snap);
  354. max_sectors = KIO_MAX_SECTORS * (min_blksize>>9);
  356. if (chunk_size % (max_blksize>>9))
  357. goto fail_blksize;
  359. while (chunk_size)
  360. {
  361. nr_sectors = min(chunk_size, max_sectors);
  362. chunk_size -= nr_sectors;
  364. iobuf->length = nr_sectors << 9;
  366. if(!lvm_snapshot_prepare_blocks(iobuf->blocks, org_start,
  367. nr_sectors, blksize_org))
  368. goto fail_prepare;
  370. if (brw_kiovec(READ, 1, &iobuf, org_phys_dev,
  371.        iobuf->blocks, blksize_org) != (nr_sectors<<9))
  372. goto fail_raw_read;
  374. if(!lvm_snapshot_prepare_blocks(iobuf->blocks, snap_start,
  375. nr_sectors, blksize_snap))
  376. goto fail_prepare;
  378. if (brw_kiovec(WRITE, 1, &iobuf, snap_phys_dev,
  379.        iobuf->blocks, blksize_snap) != (nr_sectors<<9))
  380. goto fail_raw_write;
  381. }
  383. #ifdef DEBUG_SNAPSHOT
  384. /* invalidate the logical snapshot buffer cache */
  385. invalidate_snap_cache(virt_start, lv_snap->lv_chunk_size,
  386.       lv_snap->lv_dev);
  387. #endif
  389. /* the original chunk is now stored on the snapshot volume
  390.    so update the execption table */
  391. lv_snap->lv_block_exception[idx].rdev_org = org_phys_dev;
  392. lv_snap->lv_block_exception[idx].rsector_org = org_start;
  394. lvm_hash_link(lv_snap->lv_block_exception + idx,
  395.       org_phys_dev, org_start, lv_snap);
  396. lv_snap->lv_remap_ptr = idx + 1;
  397. if (lv_snap->lv_snapshot_use_rate > 0) {
  398. if (lv_snap->lv_remap_ptr * 100 / lv_snap->lv_remap_end >= lv_snap->lv_snapshot_use_rate)
  399. wake_up_interruptible(&lv_snap->lv_snapshot_wait);
  400. }
  401. return 0;
  403. /* slow path */
  404.  out:
  405. lvm_drop_snapshot(vg, lv_snap, reason);
  406. return 1;
  408.  fail_out_of_space:
  409. reason = "out of space";
  410. goto out;
  411.  fail_raw_read:
  412. reason = "read error";
  413. goto out;
  414.  fail_raw_write:
  415. reason = "write error";
  416. goto out;
  417.  fail_blksize:
  418. reason = "blocksize error";
  419. goto out;
  421.  fail_prepare:
  422. reason = "couldn't prepare kiovec blocks "
  423. "(start probably isn't block aligned)";
  424. goto out;
  425. }
  427. int lvm_snapshot_alloc_iobuf_pages(struct kiobuf * iobuf, int sectors)
  428. {
  429. int bytes, nr_pages, err, i;
  431. bytes = sectors * SECTOR_SIZE;
  432. nr_pages = (bytes + ~PAGE_MASK) >> PAGE_SHIFT;
  433. err = expand_kiobuf(iobuf, nr_pages);
  434. if (err) goto out;
  436. err = -ENOMEM;
  437. iobuf->locked = 1;
  438. iobuf->nr_pages = 0;
  439. for (i = 0; i < nr_pages; i++)
  440. {
  441. struct page * page;
  443. page = alloc_page(GFP_KERNEL);
  444. if (!page)
  445. goto out;
  447. iobuf->maplist[i] = page;
  448. LockPage(page);
  449. iobuf->nr_pages++;
  450. }
  451. iobuf->offset = 0;
  453. err = 0;
  454.  out:
  455. return err;
  456. }
  458. static int calc_max_buckets(void)
  459. {
  460. unsigned long mem;
  462. mem = num_physpages << PAGE_SHIFT;
  463. mem /= 100;
  464. mem *= 2;
  465. mem /= sizeof(struct list_head);
  467. return mem;
  468. }
  470. int lvm_snapshot_alloc_hash_table(lv_t * lv)
  471. {
  472. int err;
  473. unsigned long buckets, max_buckets, size;
  474. struct list_head * hash;
  476. buckets = lv->lv_remap_end;
  477. max_buckets = calc_max_buckets();
  478. buckets = min(buckets, max_buckets);
  479. while (buckets & (buckets-1))
  480. buckets &= (buckets-1);
  482. size = buckets * sizeof(struct list_head);
  484. err = -ENOMEM;
  485. hash = vmalloc(size);
  486. lv->lv_snapshot_hash_table = hash;
  488. if (!hash)
  489. goto out;
  490. lv->lv_snapshot_hash_table_size = size;
  492. lv->lv_snapshot_hash_mask = buckets-1;
  493. while (buckets--)
  494. INIT_LIST_HEAD(hash+buckets);
  495. err = 0;
  496. out:
  497. return err;
  498. }
  500. int lvm_snapshot_alloc(lv_t * lv_snap)
  501. {
  502. int ret, max_sectors;
  504. /* allocate kiovec to do chunk io */
  505. ret = alloc_kiovec(1, &lv_snap->lv_iobuf);
  506. if (ret) goto out;
  508. max_sectors = KIO_MAX_SECTORS << (PAGE_SHIFT-9);
  510. ret = lvm_snapshot_alloc_iobuf_pages(lv_snap->lv_iobuf, max_sectors);
  511. if (ret) goto out_free_kiovec;
  513. /* allocate kiovec to do exception table io */
  514. ret = alloc_kiovec(1, &lv_snap->lv_COW_table_iobuf);
  515. if (ret) goto out_free_kiovec;
  517. ret = lvm_snapshot_alloc_iobuf_pages(lv_snap->lv_COW_table_iobuf,
  518.                                             PAGE_SIZE/SECTOR_SIZE);
  519. if (ret) goto out_free_both_kiovecs;
  521. ret = lvm_snapshot_alloc_hash_table(lv_snap);
  522. if (ret) goto out_free_both_kiovecs;
  525. out:
  526. return ret;
  528. out_free_both_kiovecs:
  529. unmap_kiobuf(lv_snap->lv_COW_table_iobuf);
  530. free_kiovec(1, &lv_snap->lv_COW_table_iobuf);
  531. lv_snap->lv_COW_table_iobuf = NULL;
  533. out_free_kiovec:
  534. unmap_kiobuf(lv_snap->lv_iobuf);
  535. free_kiovec(1, &lv_snap->lv_iobuf);
  536. lv_snap->lv_iobuf = NULL;
  537. if (lv_snap->lv_snapshot_hash_table != NULL)
  538. vfree(lv_snap->lv_snapshot_hash_table);
  539. lv_snap->lv_snapshot_hash_table = NULL;
  540. goto out;
  541. }
  543. void lvm_snapshot_release(lv_t * lv)
  544. {
  545. if (lv->lv_block_exception)
  546. {
  547. vfree(lv->lv_block_exception);
  548. lv->lv_block_exception = NULL;
  549. }
  550. if (lv->lv_snapshot_hash_table)
  551. {
  552. vfree(lv->lv_snapshot_hash_table);
  553. lv->lv_snapshot_hash_table = NULL;
  554. lv->lv_snapshot_hash_table_size = 0;
  555. }
  556. if (lv->lv_iobuf)
  557. {
  558.         kiobuf_wait_for_io(lv->lv_iobuf);
  559. unmap_kiobuf(lv->lv_iobuf);
  560. free_kiovec(1, &lv->lv_iobuf);
  561. lv->lv_iobuf = NULL;
  562. }
  563. if (lv->lv_COW_table_iobuf)
  564. {
  565.                kiobuf_wait_for_io(lv->lv_COW_table_iobuf);
  566.                unmap_kiobuf(lv->lv_COW_table_iobuf);
  567.                free_kiovec(1, &lv->lv_COW_table_iobuf);
  568.                lv->lv_COW_table_iobuf = NULL;
  569. }
  570. }
  573. static int _write_COW_table_block(vg_t *vg, lv_t *lv_snap,
  574.   int idx, const char **reason) {
  575. int blksize_snap;
  576. int end_of_table;
  577. int idx_COW_table;
  578. uint pvn;
  579. ulong snap_pe_start, COW_table_sector_offset,
  580. COW_entries_per_pe, COW_chunks_per_pe, COW_entries_per_block;
  581. ulong blocks[1];
  582. kdev_t snap_phys_dev;
  583. lv_block_exception_t *be;
  584. struct kiobuf * COW_table_iobuf = lv_snap->lv_COW_table_iobuf;
  585. lv_COW_table_disk_t * lv_COW_table =
  586.    ( lv_COW_table_disk_t *) page_address(lv_snap->lv_COW_table_iobuf->maplist[0]);
  588. COW_chunks_per_pe = LVM_GET_COW_TABLE_CHUNKS_PER_PE(vg, lv_snap);
  589. COW_entries_per_pe = LVM_GET_COW_TABLE_ENTRIES_PER_PE(vg, lv_snap);
  591. /* get physical addresse of destination chunk */
  592. snap_phys_dev = lv_snap->lv_block_exception[idx].rdev_new;
  593. snap_pe_start = lv_snap->lv_block_exception[idx - (idx % COW_entries_per_pe)].rsector_new - lv_snap->lv_chunk_size;
  595. blksize_snap = lvm_get_blksize(snap_phys_dev);
  597.         COW_entries_per_block = blksize_snap / sizeof(lv_COW_table_disk_t);
  598.         idx_COW_table = idx % COW_entries_per_pe % COW_entries_per_block;
  600. if ( idx_COW_table == 0) memset(lv_COW_table, 0, blksize_snap);
  602.        /* sector offset into the on disk COW table */
  603. COW_table_sector_offset = (idx % COW_entries_per_pe) / (SECTOR_SIZE / sizeof(lv_COW_table_disk_t));
  605.         /* COW table block to write next */
  606. blocks[0] = (snap_pe_start + COW_table_sector_offset) >> (blksize_snap >> 10);
  608. /* store new COW_table entry */
  609.        be = lv_snap->lv_block_exception + idx;
  610.        if(_pv_get_number(vg, be->rdev_org, &pvn))
  611.                goto fail_pv_get_number;
  613.        lv_COW_table[idx_COW_table].pv_org_number = cpu_to_le64(pvn);
  614.        lv_COW_table[idx_COW_table].pv_org_rsector =
  615.                cpu_to_le64(be->rsector_org);
  616.        if(_pv_get_number(vg, snap_phys_dev, &pvn))
  617.                goto fail_pv_get_number;
  619.        lv_COW_table[idx_COW_table].pv_snap_number = cpu_to_le64(pvn);
  620.        lv_COW_table[idx_COW_table].pv_snap_rsector =
  621.                cpu_to_le64(be->rsector_new);
  623. COW_table_iobuf->length = blksize_snap;
  625. if (brw_kiovec(WRITE, 1, &COW_table_iobuf, snap_phys_dev,
  626.        blocks, blksize_snap) != blksize_snap)
  627. goto fail_raw_write;
  629.        /* initialization of next COW exception table block with zeroes */
  630. end_of_table = idx % COW_entries_per_pe == COW_entries_per_pe - 1;
  631. if (idx_COW_table % COW_entries_per_block == COW_entries_per_block - 1 || end_of_table)
  632. {
  633. /* don't go beyond the end */
  634.                if (idx + 1 >= lv_snap->lv_remap_end) goto out;
  636. memset(lv_COW_table, 0, blksize_snap);
  638. if (end_of_table)
  639. {
  640. idx++;
  641. snap_phys_dev = lv_snap->lv_block_exception[idx].rdev_new;
  642. snap_pe_start = lv_snap->lv_block_exception[idx - (idx % COW_entries_per_pe)].rsector_new - lv_snap->lv_chunk_size;
  643. blksize_snap = lvm_get_blksize(snap_phys_dev);
  644. blocks[0] = snap_pe_start >> (blksize_snap >> 10);
  645. } else blocks[0]++;
  647.                if (brw_kiovec(WRITE, 1, &COW_table_iobuf, snap_phys_dev,
  648.                                  blocks, blksize_snap) !=
  649.                     blksize_snap)
  650. goto fail_raw_write;
  651. }
  653.  out:
  654. return 0;
  656.  fail_raw_write:
  657. *reason = "write error";
  658. return 1;
  660.  fail_pv_get_number:
  661. *reason = "_pv_get_number failed";
  662. return 1;
  663. }
  665. /*
  666.  * FIXME_1.2
  667.  * This function is a bit of a hack; we need to ensure that the
  668.  * snapshot is never made active again, because it will surely be
  669.  * corrupt.  At the moment we do not have access to the LVM metadata
  670.  * from within the kernel.  So we set the first exception to point to
  671.  * sector 1 (which will always be within the metadata, and as such
  672.  * invalid).  User land tools will check for this when they are asked
  673.  * to activate the snapshot and prevent this from happening.
  674.  */
  676. static void _disable_snapshot(vg_t *vg, lv_t *lv) {
  677. const char *err;
  678. lv->lv_block_exception[0].rsector_org = LVM_SNAPSHOT_DROPPED_SECTOR;
  679. if(_write_COW_table_block(vg, lv, 0, &err) < 0) {
  680. printk(KERN_ERR "%s -- couldn't disable snapshot: %sn",
  681.        lvm_name, err);
  682. }
  683. }
  685. MODULE_LICENSE("GPL");