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 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req) 113 { 114 int ret; 115 116 ret = nilfs_dat_prepare_entry(dat, req, 0); 117 WARN_ON(ret == -ENOENT); 118 return ret; 119 } 120 121 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req, 122 sector_t blocknr) 123 { 124 struct nilfs_dat_entry *entry; 125 void *kaddr; 126 127 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 128 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 129 req->pr_entry_bh, kaddr); 130 entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat)); 131 entry->de_blocknr = cpu_to_le64(blocknr); 132 kunmap_atomic(kaddr, KM_USER0); 133 134 nilfs_dat_commit_entry(dat, req); 135 } 136 137 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req) 138 { 139 struct nilfs_dat_entry *entry; 140 __u64 start; 141 sector_t blocknr; 142 void *kaddr; 143 int ret; 144 145 ret = nilfs_dat_prepare_entry(dat, req, 0); 146 if (ret < 0) { 147 WARN_ON(ret == -ENOENT); 148 return ret; 149 } 150 151 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 152 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 153 req->pr_entry_bh, kaddr); 154 start = le64_to_cpu(entry->de_start); 155 blocknr = le64_to_cpu(entry->de_blocknr); 156 kunmap_atomic(kaddr, KM_USER0); 157 158 if (blocknr == 0) { 159 ret = nilfs_palloc_prepare_free_entry(dat, req); 160 if (ret < 0) { 161 nilfs_dat_abort_entry(dat, req); 162 return ret; 163 } 164 } 165 166 return 0; 167 } 168 169 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req, 170 int dead) 171 { 172 struct nilfs_dat_entry *entry; 173 __u64 start, end; 174 sector_t blocknr; 175 void *kaddr; 176 177 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 178 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 179 req->pr_entry_bh, kaddr); 180 end = start = le64_to_cpu(entry->de_start); 181 if (!dead) { 182 end = nilfs_mdt_cno(dat); 183 WARN_ON(start > end); 184 } 185 entry->de_end = cpu_to_le64(end); 186 blocknr = le64_to_cpu(entry->de_blocknr); 187 kunmap_atomic(kaddr, KM_USER0); 188 189 if (blocknr == 0) 190 nilfs_dat_commit_free(dat, req); 191 else 192 nilfs_dat_commit_entry(dat, req); 193 } 194 195 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req) 196 { 197 struct nilfs_dat_entry *entry; 198 __u64 start; 199 sector_t blocknr; 200 void *kaddr; 201 202 kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0); 203 entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr, 204 req->pr_entry_bh, kaddr); 205 start = le64_to_cpu(entry->de_start); 206 blocknr = le64_to_cpu(entry->de_blocknr); 207 kunmap_atomic(kaddr, KM_USER0); 208 209 if (start == nilfs_mdt_cno(dat) && blocknr == 0) 210 nilfs_palloc_abort_free_entry(dat, req); 211 nilfs_dat_abort_entry(dat, req); 212 } 213 214 int nilfs_dat_prepare_update(struct inode *dat, 215 struct nilfs_palloc_req *oldreq, 216 struct nilfs_palloc_req *newreq) 217 { 218 int ret; 219 220 ret = nilfs_dat_prepare_end(dat, oldreq); 221 if (!ret) { 222 ret = nilfs_dat_prepare_alloc(dat, newreq); 223 if (ret < 0) 224 nilfs_dat_abort_end(dat, oldreq); 225 } 226 return ret; 227 } 228 229 void nilfs_dat_commit_update(struct inode *dat, 230 struct nilfs_palloc_req *oldreq, 231 struct nilfs_palloc_req *newreq, int dead) 232 { 233 nilfs_dat_commit_end(dat, oldreq, dead); 234 nilfs_dat_commit_alloc(dat, newreq); 235 } 236 237 void nilfs_dat_abort_update(struct inode *dat, 238 struct nilfs_palloc_req *oldreq, 239 struct nilfs_palloc_req *newreq) 240 { 241 nilfs_dat_abort_end(dat, oldreq); 242 nilfs_dat_abort_alloc(dat, newreq); 243 } 244 245 /** 246 * nilfs_dat_mark_dirty - 247 * @dat: DAT file inode 248 * @vblocknr: virtual block number 249 * 250 * Description: 251 * 252 * Return Value: On success, 0 is returned. On error, one of the following 253 * negative error codes is returned. 254 * 255 * %-EIO - I/O error. 256 * 257 * %-ENOMEM - Insufficient amount of memory available. 258 */ 259 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr) 260 { 261 struct nilfs_palloc_req req; 262 int ret; 263 264 req.pr_entry_nr = vblocknr; 265 ret = nilfs_dat_prepare_entry(dat, &req, 0); 266 if (ret == 0) 267 nilfs_dat_commit_entry(dat, &req); 268 return ret; 269 } 270 271 /** 272 * nilfs_dat_freev - free virtual block numbers 273 * @dat: DAT file inode 274 * @vblocknrs: array of virtual block numbers 275 * @nitems: number of virtual block numbers 276 * 277 * Description: nilfs_dat_freev() frees the virtual block numbers specified by 278 * @vblocknrs and @nitems. 279 * 280 * Return Value: On success, 0 is returned. On error, one of the following 281 * nagative error codes is returned. 282 * 283 * %-EIO - I/O error. 284 * 285 * %-ENOMEM - Insufficient amount of memory available. 286 * 287 * %-ENOENT - The virtual block number have not been allocated. 288 */ 289 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems) 290 { 291 return nilfs_palloc_freev(dat, vblocknrs, nitems); 292 } 293 294 /** 295 * nilfs_dat_move - change a block number 296 * @dat: DAT file inode 297 * @vblocknr: virtual block number 298 * @blocknr: block number 299 * 300 * Description: nilfs_dat_move() changes the block number associated with 301 * @vblocknr to @blocknr. 302 * 303 * Return Value: On success, 0 is returned. On error, one of the following 304 * negative error codes is returned. 305 * 306 * %-EIO - I/O error. 307 * 308 * %-ENOMEM - Insufficient amount of memory available. 309 */ 310 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr) 311 { 312 struct buffer_head *entry_bh; 313 struct nilfs_dat_entry *entry; 314 void *kaddr; 315 int ret; 316 317 ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh); 318 if (ret < 0) 319 return ret; 320 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 321 entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr); 322 if (unlikely(entry->de_blocknr == cpu_to_le64(0))) { 323 printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__, 324 (unsigned long long)vblocknr, 325 (unsigned long long)le64_to_cpu(entry->de_start), 326 (unsigned long long)le64_to_cpu(entry->de_end)); 327 kunmap_atomic(kaddr, KM_USER0); 328 brelse(entry_bh); 329 return -EINVAL; 330 } 331 WARN_ON(blocknr == 0); 332 entry->de_blocknr = cpu_to_le64(blocknr); 333 kunmap_atomic(kaddr, KM_USER0); 334 335 nilfs_mdt_mark_buffer_dirty(entry_bh); 336 nilfs_mdt_mark_dirty(dat); 337 338 brelse(entry_bh); 339 340 return 0; 341 } 342 343 /** 344 * nilfs_dat_translate - translate a virtual block number to a block number 345 * @dat: DAT file inode 346 * @vblocknr: virtual block number 347 * @blocknrp: pointer to a block number 348 * 349 * Description: nilfs_dat_translate() maps the virtual block number @vblocknr 350 * to the corresponding block number. 351 * 352 * Return Value: On success, 0 is returned and the block number associated 353 * with @vblocknr is stored in the place pointed by @blocknrp. On error, one 354 * of the following negative error codes is returned. 355 * 356 * %-EIO - I/O error. 357 * 358 * %-ENOMEM - Insufficient amount of memory available. 359 * 360 * %-ENOENT - A block number associated with @vblocknr does not exist. 361 */ 362 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp) 363 { 364 struct buffer_head *entry_bh; 365 struct nilfs_dat_entry *entry; 366 sector_t blocknr; 367 void *kaddr; 368 int ret; 369 370 ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh); 371 if (ret < 0) 372 return ret; 373 374 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 375 entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr); 376 blocknr = le64_to_cpu(entry->de_blocknr); 377 if (blocknr == 0) { 378 ret = -ENOENT; 379 goto out; 380 } 381 if (blocknrp != NULL) 382 *blocknrp = blocknr; 383 384 out: 385 kunmap_atomic(kaddr, KM_USER0); 386 brelse(entry_bh); 387 return ret; 388 } 389 390 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz, 391 size_t nvi) 392 { 393 struct buffer_head *entry_bh; 394 struct nilfs_dat_entry *entry; 395 struct nilfs_vinfo *vinfo = buf; 396 __u64 first, last; 397 void *kaddr; 398 unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block; 399 int i, j, n, ret; 400 401 for (i = 0; i < nvi; i += n) { 402 ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr, 403 0, &entry_bh); 404 if (ret < 0) 405 return ret; 406 kaddr = kmap_atomic(entry_bh->b_page, KM_USER0); 407 /* last virtual block number in this block */ 408 first = vinfo->vi_vblocknr; 409 do_div(first, entries_per_block); 410 first *= entries_per_block; 411 last = first + entries_per_block - 1; 412 for (j = i, n = 0; 413 j < nvi && vinfo->vi_vblocknr >= first && 414 vinfo->vi_vblocknr <= last; 415 j++, n++, vinfo = (void *)vinfo + visz) { 416 entry = nilfs_palloc_block_get_entry( 417 dat, vinfo->vi_vblocknr, entry_bh, kaddr); 418 vinfo->vi_start = le64_to_cpu(entry->de_start); 419 vinfo->vi_end = le64_to_cpu(entry->de_end); 420 vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr); 421 } 422 kunmap_atomic(kaddr, KM_USER0); 423 brelse(entry_bh); 424 } 425 426 return nvi; 427 } 428