1 /* 2 * dat.c - NILFS disk address translation. 3 * 4 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Koji Sato <koji@osrg.net>. 21 */ 22 23 #include <linux/types.h> 24 #include <linux/buffer_head.h> 25 #include <linux/string.h> 26 #include <linux/errno.h> 27 #include "nilfs.h" 28 #include "mdt.h" 29 #include "alloc.h" 30 #include "dat.h" 31 32 33 #define NILFS_CNO_MIN ((__u64)1) 34 #define NILFS_CNO_MAX (~(__u64)0) 35 36 static int nilfs_dat_prepare_entry(struct inode *dat, 37 struct nilfs_palloc_req *req, int create) 38 { 39 return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr, 40 create, &req->pr_entry_bh); 41 } 42 43 static void nilfs_dat_commit_entry(struct inode *dat, 44 struct nilfs_palloc_req *req) 45 { 46 nilfs_mdt_mark_buffer_dirty(req->pr_entry_bh); 47 nilfs_mdt_mark_dirty(dat); 48 brelse(req->pr_entry_bh); 49 } 50 51 static void nilfs_dat_abort_entry(struct inode *dat, 52 struct nilfs_palloc_req *req) 53 { 54 brelse(req->pr_entry_bh); 55 } 56 57 int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req) 58 { 59 int ret; 60 61 ret = nilfs_palloc_prepare_alloc_entry(dat, req); 62 if (ret < 0) 63 return ret; 64 65 ret = nilfs_dat_prepare_entry(dat, req, 1); 66 if (ret < 0) 67 nilfs_palloc_abort_alloc_entry(dat, req); 68 69 return ret; 70 } 71 72 void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req) 73 { 74 struct nilfs_dat_entry *entry; 75 void *kaddr; 76 77 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 78 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 79 req->pr_entry_bh, kaddr); 80 entry->de_start = cpu_to_le64(NILFS_CNO_MIN); 81 entry->de_end = cpu_to_le64(NILFS_CNO_MAX); 82 entry->de_blocknr = cpu_to_le64(0); 83 kunmap_atomic(kaddr, KM_USER0); 84 85 nilfs_palloc_commit_alloc_entry(dat, req); 86 nilfs_dat_commit_entry(dat, req); 87 } 88 89 void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req) 90 { 91 nilfs_dat_abort_entry(dat, req); 92 nilfs_palloc_abort_alloc_entry(dat, req); 93 } 94 95 void nilfs_dat_commit_free(struct inode *dat, struct nilfs_palloc_req *req) 96 { 97 struct nilfs_dat_entry *entry; 98 void *kaddr; 99 100 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 101 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 102 req->pr_entry_bh, kaddr); 103 entry->de_start = cpu_to_le64(NILFS_CNO_MIN); 104 entry->de_end = cpu_to_le64(NILFS_CNO_MIN); 105 entry->de_blocknr = cpu_to_le64(0); 106 kunmap_atomic(kaddr, KM_USER0); 107 108 nilfs_dat_commit_entry(dat, req); 109 nilfs_palloc_commit_free_entry(dat, req); 110 } 111 112 void nilfs_dat_abort_free(struct inode *dat, struct nilfs_palloc_req *req) 113 { 114 nilfs_dat_abort_entry(dat, req); 115 nilfs_palloc_abort_free_entry(dat, req); 116 } 117 118 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req) 119 { 120 int ret; 121 122 ret = nilfs_dat_prepare_entry(dat, req, 0); 123 WARN_ON(ret == -ENOENT); 124 return ret; 125 } 126 127 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req, 128 sector_t blocknr) 129 { 130 struct nilfs_dat_entry *entry; 131 void *kaddr; 132 133 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 134 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 135 req->pr_entry_bh, kaddr); 136 entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat)); 137 entry->de_blocknr = cpu_to_le64(blocknr); 138 kunmap_atomic(kaddr, KM_USER0); 139 140 nilfs_dat_commit_entry(dat, req); 141 } 142 143 void nilfs_dat_abort_start(struct inode *dat, struct nilfs_palloc_req *req) 144 { 145 nilfs_dat_abort_entry(dat, req); 146 } 147 148 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req) 149 { 150 struct nilfs_dat_entry *entry; 151 __u64 start; 152 sector_t blocknr; 153 void *kaddr; 154 int ret; 155 156 ret = nilfs_dat_prepare_entry(dat, req, 0); 157 if (ret < 0) { 158 WARN_ON(ret == -ENOENT); 159 return ret; 160 } 161 162 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 163 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 164 req->pr_entry_bh, kaddr); 165 start = le64_to_cpu(entry->de_start); 166 blocknr = le64_to_cpu(entry->de_blocknr); 167 kunmap_atomic(kaddr, KM_USER0); 168 169 if (blocknr == 0) { 170 ret = nilfs_palloc_prepare_free_entry(dat, req); 171 if (ret < 0) { 172 nilfs_dat_abort_entry(dat, req); 173 return ret; 174 } 175 } 176 177 return 0; 178 } 179 180 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req, 181 int dead) 182 { 183 struct nilfs_dat_entry *entry; 184 __u64 start, end; 185 sector_t blocknr; 186 void *kaddr; 187 188 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 189 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 190 req->pr_entry_bh, kaddr); 191 end = start = le64_to_cpu(entry->de_start); 192 if (!dead) { 193 end = nilfs_mdt_cno(dat); 194 WARN_ON(start > end); 195 } 196 entry->de_end = cpu_to_le64(end); 197 blocknr = le64_to_cpu(entry->de_blocknr); 198 kunmap_atomic(kaddr, KM_USER0); 199 200 if (blocknr == 0) 201 nilfs_dat_commit_free(dat, req); 202 else 203 nilfs_dat_commit_entry(dat, req); 204 } 205 206 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req) 207 { 208 struct nilfs_dat_entry *entry; 209 __u64 start; 210 sector_t blocknr; 211 void *kaddr; 212 213 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 214 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 215 req->pr_entry_bh, kaddr); 216 start = le64_to_cpu(entry->de_start); 217 blocknr = le64_to_cpu(entry->de_blocknr); 218 kunmap_atomic(kaddr, KM_USER0); 219 220 if (start == nilfs_mdt_cno(dat) && blocknr == 0) 221 nilfs_palloc_abort_free_entry(dat, req); 222 nilfs_dat_abort_entry(dat, req); 223 } 224 225 /** 226 * nilfs_dat_mark_dirty - 227 * @dat: DAT file inode 228 * @vblocknr: virtual block number 229 * 230 * Description: 231 * 232 * Return Value: On success, 0 is returned. On error, one of the following 233 * negative error codes is returned. 234 * 235 * %-EIO - I/O error. 236 * 237 * %-ENOMEM - Insufficient amount of memory available. 238 */ 239 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr) 240 { 241 struct nilfs_palloc_req req; 242 int ret; 243 244 req.pr_entry_nr = vblocknr; 245 ret = nilfs_dat_prepare_entry(dat, &req, 0); 246 if (ret == 0) 247 nilfs_dat_commit_entry(dat, &req); 248 return ret; 249 } 250 251 /** 252 * nilfs_dat_freev - free virtual block numbers 253 * @dat: DAT file inode 254 * @vblocknrs: array of virtual block numbers 255 * @nitems: number of virtual block numbers 256 * 257 * Description: nilfs_dat_freev() frees the virtual block numbers specified by 258 * @vblocknrs and @nitems. 259 * 260 * Return Value: On success, 0 is returned. On error, one of the following 261 * nagative error codes is returned. 262 * 263 * %-EIO - I/O error. 264 * 265 * %-ENOMEM - Insufficient amount of memory available. 266 * 267 * %-ENOENT - The virtual block number have not been allocated. 268 */ 269 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems) 270 { 271 return nilfs_palloc_freev(dat, vblocknrs, nitems); 272 } 273 274 /** 275 * nilfs_dat_move - change a block number 276 * @dat: DAT file inode 277 * @vblocknr: virtual block number 278 * @blocknr: block number 279 * 280 * Description: nilfs_dat_move() changes the block number associated with 281 * @vblocknr to @blocknr. 282 * 283 * Return Value: On success, 0 is returned. On error, one of the following 284 * negative error codes is returned. 285 * 286 * %-EIO - I/O error. 287 * 288 * %-ENOMEM - Insufficient amount of memory available. 289 */ 290 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr) 291 { 292 struct buffer_head *entry_bh; 293 struct nilfs_dat_entry *entry; 294 void *kaddr; 295 int ret; 296 297 ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh); 298 if (ret < 0) 299 return ret; 300 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 301 entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr); 302 if (unlikely(entry->de_blocknr == cpu_to_le64(0))) { 303 printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__, 304 (unsigned long long)vblocknr, 305 (unsigned long long)le64_to_cpu(entry->de_start), 306 (unsigned long long)le64_to_cpu(entry->de_end)); 307 kunmap_atomic(kaddr, KM_USER0); 308 brelse(entry_bh); 309 return -EINVAL; 310 } 311 WARN_ON(blocknr == 0); 312 entry->de_blocknr = cpu_to_le64(blocknr); 313 kunmap_atomic(kaddr, KM_USER0); 314 315 nilfs_mdt_mark_buffer_dirty(entry_bh); 316 nilfs_mdt_mark_dirty(dat); 317 318 brelse(entry_bh); 319 320 return 0; 321 } 322 323 /** 324 * nilfs_dat_translate - translate a virtual block number to a block number 325 * @dat: DAT file inode 326 * @vblocknr: virtual block number 327 * @blocknrp: pointer to a block number 328 * 329 * Description: nilfs_dat_translate() maps the virtual block number @vblocknr 330 * to the corresponding block number. 331 * 332 * Return Value: On success, 0 is returned and the block number associated 333 * with @vblocknr is stored in the place pointed by @blocknrp. On error, one 334 * of the following negative error codes is returned. 335 * 336 * %-EIO - I/O error. 337 * 338 * %-ENOMEM - Insufficient amount of memory available. 339 * 340 * %-ENOENT - A block number associated with @vblocknr does not exist. 341 */ 342 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp) 343 { 344 struct buffer_head *entry_bh; 345 struct nilfs_dat_entry *entry; 346 sector_t blocknr; 347 void *kaddr; 348 int ret; 349 350 ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh); 351 if (ret < 0) 352 return ret; 353 354 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 355 entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr); 356 blocknr = le64_to_cpu(entry->de_blocknr); 357 if (blocknr == 0) { 358 ret = -ENOENT; 359 goto out; 360 } 361 if (blocknrp != NULL) 362 *blocknrp = blocknr; 363 364 out: 365 kunmap_atomic(kaddr, KM_USER0); 366 brelse(entry_bh); 367 return ret; 368 } 369 370 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz, 371 size_t nvi) 372 { 373 struct buffer_head *entry_bh; 374 struct nilfs_dat_entry *entry; 375 struct nilfs_vinfo *vinfo = buf; 376 __u64 first, last; 377 void *kaddr; 378 unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block; 379 int i, j, n, ret; 380 381 for (i = 0; i < nvi; i += n) { 382 ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr, 383 0, &entry_bh); 384 if (ret < 0) 385 return ret; 386 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 387 /* last virtual block number in this block */ 388 first = vinfo->vi_vblocknr; 389 do_div(first, entries_per_block); 390 first *= entries_per_block; 391 last = first + entries_per_block - 1; 392 for (j = i, n = 0; 393 j < nvi && vinfo->vi_vblocknr >= first && 394 vinfo->vi_vblocknr <= last; 395 j++, n++, vinfo = (void *)vinfo + visz) { 396 entry = nilfs_palloc_block_get_entry( 397 dat, vinfo->vi_vblocknr, entry_bh, kaddr); 398 vinfo->vi_start = le64_to_cpu(entry->de_start); 399 vinfo->vi_end = le64_to_cpu(entry->de_end); 400 vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr); 401 } 402 kunmap_atomic(kaddr, KM_USER0); 403 brelse(entry_bh); 404 } 405 406 return nvi; 407 } 408