util.c 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/ufs/util.c
  4. *
  5. * Copyright (C) 1998
  6. * Daniel Pirkl <daniel.pirkl@email.cz>
  7. * Charles University, Faculty of Mathematics and Physics
  8. */
  9. #include <linux/string.h>
  10. #include <linux/slab.h>
  11. #include <linux/buffer_head.h>
  12. #include "ufs_fs.h"
  13. #include "ufs.h"
  14. #include "swab.h"
  15. #include "util.h"
  16. struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi,
  17. struct super_block *sb, u64 fragment, u64 size)
  18. {
  19. struct ufs_buffer_head * ubh;
  20. unsigned i, j ;
  21. u64 count = 0;
  22. if (size & ~uspi->s_fmask)
  23. return NULL;
  24. count = size >> uspi->s_fshift;
  25. if (count > UFS_MAXFRAG)
  26. return NULL;
  27. ubh = kmalloc (sizeof (struct ufs_buffer_head), GFP_NOFS);
  28. if (!ubh)
  29. return NULL;
  30. ubh->fragment = fragment;
  31. ubh->count = count;
  32. for (i = 0; i < count; i++)
  33. if (!(ubh->bh[i] = sb_bread(sb, fragment + i)))
  34. goto failed;
  35. for (; i < UFS_MAXFRAG; i++)
  36. ubh->bh[i] = NULL;
  37. return ubh;
  38. failed:
  39. for (j = 0; j < i; j++)
  40. brelse (ubh->bh[j]);
  41. kfree(ubh);
  42. return NULL;
  43. }
  44. struct ufs_buffer_head * ubh_bread_uspi (struct ufs_sb_private_info * uspi,
  45. struct super_block *sb, u64 fragment, u64 size)
  46. {
  47. unsigned i, j;
  48. u64 count = 0;
  49. if (size & ~uspi->s_fmask)
  50. return NULL;
  51. count = size >> uspi->s_fshift;
  52. if (count <= 0 || count > UFS_MAXFRAG)
  53. return NULL;
  54. USPI_UBH(uspi)->fragment = fragment;
  55. USPI_UBH(uspi)->count = count;
  56. for (i = 0; i < count; i++)
  57. if (!(USPI_UBH(uspi)->bh[i] = sb_bread(sb, fragment + i)))
  58. goto failed;
  59. for (; i < UFS_MAXFRAG; i++)
  60. USPI_UBH(uspi)->bh[i] = NULL;
  61. return USPI_UBH(uspi);
  62. failed:
  63. for (j = 0; j < i; j++)
  64. brelse (USPI_UBH(uspi)->bh[j]);
  65. return NULL;
  66. }
  67. void ubh_brelse (struct ufs_buffer_head * ubh)
  68. {
  69. unsigned i;
  70. if (!ubh)
  71. return;
  72. for (i = 0; i < ubh->count; i++)
  73. brelse (ubh->bh[i]);
  74. kfree (ubh);
  75. }
  76. void ubh_brelse_uspi (struct ufs_sb_private_info * uspi)
  77. {
  78. unsigned i;
  79. if (!USPI_UBH(uspi))
  80. return;
  81. for ( i = 0; i < USPI_UBH(uspi)->count; i++ ) {
  82. brelse (USPI_UBH(uspi)->bh[i]);
  83. USPI_UBH(uspi)->bh[i] = NULL;
  84. }
  85. }
  86. void ubh_mark_buffer_dirty (struct ufs_buffer_head * ubh)
  87. {
  88. unsigned i;
  89. if (!ubh)
  90. return;
  91. for ( i = 0; i < ubh->count; i++ )
  92. mark_buffer_dirty (ubh->bh[i]);
  93. }
  94. void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag)
  95. {
  96. unsigned i;
  97. if (!ubh)
  98. return;
  99. if (flag) {
  100. for ( i = 0; i < ubh->count; i++ )
  101. set_buffer_uptodate (ubh->bh[i]);
  102. } else {
  103. for ( i = 0; i < ubh->count; i++ )
  104. clear_buffer_uptodate (ubh->bh[i]);
  105. }
  106. }
  107. void ubh_sync_block(struct ufs_buffer_head *ubh)
  108. {
  109. if (ubh) {
  110. unsigned i;
  111. for (i = 0; i < ubh->count; i++)
  112. write_dirty_buffer(ubh->bh[i], 0);
  113. for (i = 0; i < ubh->count; i++)
  114. wait_on_buffer(ubh->bh[i]);
  115. }
  116. }
  117. void ubh_bforget (struct ufs_buffer_head * ubh)
  118. {
  119. unsigned i;
  120. if (!ubh)
  121. return;
  122. for ( i = 0; i < ubh->count; i++ ) if ( ubh->bh[i] )
  123. bforget (ubh->bh[i]);
  124. }
  125. int ubh_buffer_dirty (struct ufs_buffer_head * ubh)
  126. {
  127. unsigned i;
  128. unsigned result = 0;
  129. if (!ubh)
  130. return 0;
  131. for ( i = 0; i < ubh->count; i++ )
  132. result |= buffer_dirty(ubh->bh[i]);
  133. return result;
  134. }
  135. void _ubh_ubhcpymem_(struct ufs_sb_private_info * uspi,
  136. unsigned char * mem, struct ufs_buffer_head * ubh, unsigned size)
  137. {
  138. unsigned len, bhno;
  139. if (size > (ubh->count << uspi->s_fshift))
  140. size = ubh->count << uspi->s_fshift;
  141. bhno = 0;
  142. while (size) {
  143. len = min_t(unsigned int, size, uspi->s_fsize);
  144. memcpy (mem, ubh->bh[bhno]->b_data, len);
  145. mem += uspi->s_fsize;
  146. size -= len;
  147. bhno++;
  148. }
  149. }
  150. void _ubh_memcpyubh_(struct ufs_sb_private_info * uspi,
  151. struct ufs_buffer_head * ubh, unsigned char * mem, unsigned size)
  152. {
  153. unsigned len, bhno;
  154. if (size > (ubh->count << uspi->s_fshift))
  155. size = ubh->count << uspi->s_fshift;
  156. bhno = 0;
  157. while (size) {
  158. len = min_t(unsigned int, size, uspi->s_fsize);
  159. memcpy (ubh->bh[bhno]->b_data, mem, len);
  160. mem += uspi->s_fsize;
  161. size -= len;
  162. bhno++;
  163. }
  164. }
  165. dev_t
  166. ufs_get_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi)
  167. {
  168. __u32 fs32;
  169. dev_t dev;
  170. if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
  171. fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[1]);
  172. else
  173. fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[0]);
  174. switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
  175. case UFS_ST_SUNx86:
  176. case UFS_ST_SUN:
  177. if ((fs32 & 0xffff0000) == 0 ||
  178. (fs32 & 0xffff0000) == 0xffff0000)
  179. dev = old_decode_dev(fs32 & 0x7fff);
  180. else
  181. dev = MKDEV(sysv_major(fs32), sysv_minor(fs32));
  182. break;
  183. default:
  184. dev = old_decode_dev(fs32);
  185. break;
  186. }
  187. return dev;
  188. }
  189. void
  190. ufs_set_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi, dev_t dev)
  191. {
  192. __u32 fs32;
  193. switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
  194. case UFS_ST_SUNx86:
  195. case UFS_ST_SUN:
  196. fs32 = sysv_encode_dev(dev);
  197. if ((fs32 & 0xffff8000) == 0) {
  198. fs32 = old_encode_dev(dev);
  199. }
  200. break;
  201. default:
  202. fs32 = old_encode_dev(dev);
  203. break;
  204. }
  205. if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
  206. ufsi->i_u1.i_data[1] = cpu_to_fs32(sb, fs32);
  207. else
  208. ufsi->i_u1.i_data[0] = cpu_to_fs32(sb, fs32);
  209. }
  210. /**
  211. * ufs_get_locked_page() - locate, pin and lock a pagecache page, if not exist
  212. * read it from disk.
  213. * @mapping: the address_space to search
  214. * @index: the page index
  215. *
  216. * Locates the desired pagecache page, if not exist we'll read it,
  217. * locks it, increments its reference
  218. * count and returns its address.
  219. *
  220. */
  221. struct page *ufs_get_locked_page(struct address_space *mapping,
  222. pgoff_t index)
  223. {
  224. struct inode *inode = mapping->host;
  225. struct page *page = find_lock_page(mapping, index);
  226. if (!page) {
  227. page = read_mapping_page(mapping, index, NULL);
  228. if (IS_ERR(page)) {
  229. printk(KERN_ERR "ufs_change_blocknr: "
  230. "read_mapping_page error: ino %lu, index: %lu\n",
  231. mapping->host->i_ino, index);
  232. return page;
  233. }
  234. lock_page(page);
  235. if (unlikely(page->mapping == NULL)) {
  236. /* Truncate got there first */
  237. unlock_page(page);
  238. put_page(page);
  239. return NULL;
  240. }
  241. if (!PageUptodate(page) || PageError(page)) {
  242. unlock_page(page);
  243. put_page(page);
  244. printk(KERN_ERR "ufs_change_blocknr: "
  245. "can not read page: ino %lu, index: %lu\n",
  246. inode->i_ino, index);
  247. return ERR_PTR(-EIO);
  248. }
  249. }
  250. if (!page_has_buffers(page))
  251. create_empty_buffers(page, 1 << inode->i_blkbits, 0);
  252. return page;
  253. }