inode.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286
  1. /* -*- mode: c; c-basic-offset: 8; -*-
  2. * vim: noexpandtab sw=8 ts=8 sts=0:
  3. *
  4. * inode.c
  5. *
  6. * vfs' aops, fops, dops and iops
  7. *
  8. * Copyright (C) 2002, 2004 Oracle. All rights reserved.
  9. *
  10. * This program is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU General Public
  12. * License as published by the Free Software Foundation; either
  13. * version 2 of the License, or (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public
  21. * License along with this program; if not, write to the
  22. * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23. * Boston, MA 021110-1307, USA.
  24. */
  25. #include <linux/fs.h>
  26. #include <linux/types.h>
  27. #include <linux/slab.h>
  28. #include <linux/highmem.h>
  29. #include <linux/pagemap.h>
  30. #include <linux/smp_lock.h>
  31. #include <asm/byteorder.h>
  32. #define MLOG_MASK_PREFIX ML_INODE
  33. #include <cluster/masklog.h>
  34. #include "ocfs2.h"
  35. #include "alloc.h"
  36. #include "dlmglue.h"
  37. #include "extent_map.h"
  38. #include "file.h"
  39. #include "heartbeat.h"
  40. #include "inode.h"
  41. #include "journal.h"
  42. #include "namei.h"
  43. #include "suballoc.h"
  44. #include "super.h"
  45. #include "symlink.h"
  46. #include "sysfile.h"
  47. #include "uptodate.h"
  48. #include "vote.h"
  49. #include "buffer_head_io.h"
  50. struct ocfs2_find_inode_args
  51. {
  52. u64 fi_blkno;
  53. unsigned long fi_ino;
  54. unsigned int fi_flags;
  55. };
  56. static int ocfs2_read_locked_inode(struct inode *inode,
  57. struct ocfs2_find_inode_args *args);
  58. static int ocfs2_init_locked_inode(struct inode *inode, void *opaque);
  59. static int ocfs2_find_actor(struct inode *inode, void *opaque);
  60. static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
  61. struct inode *inode,
  62. struct buffer_head *fe_bh);
  63. void ocfs2_set_inode_flags(struct inode *inode)
  64. {
  65. unsigned int flags = OCFS2_I(inode)->ip_attr;
  66. inode->i_flags &= ~(S_IMMUTABLE |
  67. S_SYNC | S_APPEND | S_NOATIME | S_DIRSYNC);
  68. if (flags & OCFS2_IMMUTABLE_FL)
  69. inode->i_flags |= S_IMMUTABLE;
  70. if (flags & OCFS2_SYNC_FL)
  71. inode->i_flags |= S_SYNC;
  72. if (flags & OCFS2_APPEND_FL)
  73. inode->i_flags |= S_APPEND;
  74. if (flags & OCFS2_NOATIME_FL)
  75. inode->i_flags |= S_NOATIME;
  76. if (flags & OCFS2_DIRSYNC_FL)
  77. inode->i_flags |= S_DIRSYNC;
  78. }
  79. struct inode *ocfs2_ilookup_for_vote(struct ocfs2_super *osb,
  80. u64 blkno,
  81. int delete_vote)
  82. {
  83. struct ocfs2_find_inode_args args;
  84. /* ocfs2_ilookup_for_vote should *only* be called from the
  85. * vote thread */
  86. BUG_ON(current != osb->vote_task);
  87. args.fi_blkno = blkno;
  88. args.fi_flags = OCFS2_FI_FLAG_NOWAIT;
  89. if (delete_vote)
  90. args.fi_flags |= OCFS2_FI_FLAG_DELETE;
  91. args.fi_ino = ino_from_blkno(osb->sb, blkno);
  92. return ilookup5(osb->sb, args.fi_ino, ocfs2_find_actor, &args);
  93. }
  94. struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, int flags)
  95. {
  96. struct inode *inode = NULL;
  97. struct super_block *sb = osb->sb;
  98. struct ocfs2_find_inode_args args;
  99. mlog_entry("(blkno = %llu)\n", (unsigned long long)blkno);
  100. /* Ok. By now we've either got the offsets passed to us by the
  101. * caller, or we just pulled them off the bh. Lets do some
  102. * sanity checks to make sure they're OK. */
  103. if (blkno == 0) {
  104. inode = ERR_PTR(-EINVAL);
  105. mlog_errno(PTR_ERR(inode));
  106. goto bail;
  107. }
  108. args.fi_blkno = blkno;
  109. args.fi_flags = flags;
  110. args.fi_ino = ino_from_blkno(sb, blkno);
  111. inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor,
  112. ocfs2_init_locked_inode, &args);
  113. /* inode was *not* in the inode cache. 2.6.x requires
  114. * us to do our own read_inode call and unlock it
  115. * afterwards. */
  116. if (inode && inode->i_state & I_NEW) {
  117. mlog(0, "Inode was not in inode cache, reading it.\n");
  118. ocfs2_read_locked_inode(inode, &args);
  119. unlock_new_inode(inode);
  120. }
  121. if (inode == NULL) {
  122. inode = ERR_PTR(-ENOMEM);
  123. mlog_errno(PTR_ERR(inode));
  124. goto bail;
  125. }
  126. if (is_bad_inode(inode)) {
  127. iput(inode);
  128. inode = ERR_PTR(-ESTALE);
  129. mlog_errno(PTR_ERR(inode));
  130. goto bail;
  131. }
  132. bail:
  133. if (!IS_ERR(inode)) {
  134. mlog(0, "returning inode with number %llu\n",
  135. (unsigned long long)OCFS2_I(inode)->ip_blkno);
  136. mlog_exit_ptr(inode);
  137. } else
  138. mlog_errno(PTR_ERR(inode));
  139. return inode;
  140. }
  141. /*
  142. * here's how inodes get read from disk:
  143. * iget5_locked -> find_actor -> OCFS2_FIND_ACTOR
  144. * found? : return the in-memory inode
  145. * not found? : get_new_inode -> OCFS2_INIT_LOCKED_INODE
  146. */
  147. static int ocfs2_find_actor(struct inode *inode, void *opaque)
  148. {
  149. struct ocfs2_find_inode_args *args = NULL;
  150. struct ocfs2_inode_info *oi = OCFS2_I(inode);
  151. int ret = 0;
  152. mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque);
  153. args = opaque;
  154. mlog_bug_on_msg(!inode, "No inode in find actor!\n");
  155. if (oi->ip_blkno != args->fi_blkno)
  156. goto bail;
  157. /* OCFS2_FI_FLAG_NOWAIT is *only* set from
  158. * ocfs2_ilookup_for_vote which won't create an inode for one
  159. * that isn't found. The vote thread which doesn't want to get
  160. * an inode which is in the process of going away - otherwise
  161. * the call to __wait_on_freeing_inode in find_inode_fast will
  162. * cause it to deadlock on an inode which may be waiting on a
  163. * vote (or lock release) in delete_inode */
  164. if ((args->fi_flags & OCFS2_FI_FLAG_NOWAIT) &&
  165. (inode->i_state & (I_FREEING|I_CLEAR))) {
  166. /* As stated above, we're not going to return an
  167. * inode. In the case of a delete vote, the voting
  168. * code is going to signal the other node to go
  169. * ahead. Mark that state here, so this freeing inode
  170. * has the state when it gets to delete_inode. */
  171. if (args->fi_flags & OCFS2_FI_FLAG_DELETE) {
  172. spin_lock(&oi->ip_lock);
  173. ocfs2_mark_inode_remotely_deleted(inode);
  174. spin_unlock(&oi->ip_lock);
  175. }
  176. goto bail;
  177. }
  178. ret = 1;
  179. bail:
  180. mlog_exit(ret);
  181. return ret;
  182. }
  183. /*
  184. * initialize the new inode, but don't do anything that would cause
  185. * us to sleep.
  186. * return 0 on success, 1 on failure
  187. */
  188. static int ocfs2_init_locked_inode(struct inode *inode, void *opaque)
  189. {
  190. struct ocfs2_find_inode_args *args = opaque;
  191. mlog_entry("inode = %p, opaque = %p\n", inode, opaque);
  192. inode->i_ino = args->fi_ino;
  193. OCFS2_I(inode)->ip_blkno = args->fi_blkno;
  194. mlog_exit(0);
  195. return 0;
  196. }
  197. int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
  198. int create_ino)
  199. {
  200. struct super_block *sb;
  201. struct ocfs2_super *osb;
  202. int status = -EINVAL;
  203. mlog_entry("(0x%p, size:%llu)\n", inode,
  204. (unsigned long long)fe->i_size);
  205. sb = inode->i_sb;
  206. osb = OCFS2_SB(sb);
  207. /* this means that read_inode cannot create a superblock inode
  208. * today. change if needed. */
  209. if (!OCFS2_IS_VALID_DINODE(fe) ||
  210. !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))) {
  211. mlog(ML_ERROR, "Invalid dinode: i_ino=%lu, i_blkno=%llu, "
  212. "signature = %.*s, flags = 0x%x\n",
  213. inode->i_ino,
  214. (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
  215. fe->i_signature, le32_to_cpu(fe->i_flags));
  216. goto bail;
  217. }
  218. if (le32_to_cpu(fe->i_fs_generation) != osb->fs_generation) {
  219. mlog(ML_ERROR, "file entry generation does not match "
  220. "superblock! osb->fs_generation=%x, "
  221. "fe->i_fs_generation=%x\n",
  222. osb->fs_generation, le32_to_cpu(fe->i_fs_generation));
  223. goto bail;
  224. }
  225. inode->i_version = 1;
  226. inode->i_generation = le32_to_cpu(fe->i_generation);
  227. inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
  228. inode->i_mode = le16_to_cpu(fe->i_mode);
  229. inode->i_uid = le32_to_cpu(fe->i_uid);
  230. inode->i_gid = le32_to_cpu(fe->i_gid);
  231. inode->i_blksize = (u32)osb->s_clustersize;
  232. /* Fast symlinks will have i_size but no allocated clusters. */
  233. if (S_ISLNK(inode->i_mode) && !fe->i_clusters)
  234. inode->i_blocks = 0;
  235. else
  236. inode->i_blocks =
  237. ocfs2_align_bytes_to_sectors(le64_to_cpu(fe->i_size));
  238. inode->i_mapping->a_ops = &ocfs2_aops;
  239. inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
  240. inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
  241. inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
  242. inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
  243. inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
  244. inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
  245. if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno))
  246. mlog(ML_ERROR,
  247. "ip_blkno %llu != i_blkno %llu!\n",
  248. (unsigned long long)OCFS2_I(inode)->ip_blkno,
  249. (unsigned long long)fe->i_blkno);
  250. OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
  251. OCFS2_I(inode)->ip_orphaned_slot = OCFS2_INVALID_SLOT;
  252. OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
  253. inode->i_nlink = le16_to_cpu(fe->i_links_count);
  254. if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL))
  255. OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE;
  256. if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) {
  257. OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
  258. mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino);
  259. } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) {
  260. OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
  261. } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) {
  262. mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino);
  263. /* we can't actually hit this as read_inode can't
  264. * handle superblocks today ;-) */
  265. BUG();
  266. }
  267. switch (inode->i_mode & S_IFMT) {
  268. case S_IFREG:
  269. inode->i_fop = &ocfs2_fops;
  270. inode->i_op = &ocfs2_file_iops;
  271. i_size_write(inode, le64_to_cpu(fe->i_size));
  272. break;
  273. case S_IFDIR:
  274. inode->i_op = &ocfs2_dir_iops;
  275. inode->i_fop = &ocfs2_dops;
  276. i_size_write(inode, le64_to_cpu(fe->i_size));
  277. break;
  278. case S_IFLNK:
  279. if (ocfs2_inode_is_fast_symlink(inode))
  280. inode->i_op = &ocfs2_fast_symlink_inode_operations;
  281. else
  282. inode->i_op = &ocfs2_symlink_inode_operations;
  283. i_size_write(inode, le64_to_cpu(fe->i_size));
  284. break;
  285. default:
  286. inode->i_op = &ocfs2_special_file_iops;
  287. init_special_inode(inode, inode->i_mode,
  288. inode->i_rdev);
  289. break;
  290. }
  291. if (create_ino) {
  292. inode->i_ino = ino_from_blkno(inode->i_sb,
  293. le64_to_cpu(fe->i_blkno));
  294. /*
  295. * If we ever want to create system files from kernel,
  296. * the generation argument to
  297. * ocfs2_inode_lock_res_init() will have to change.
  298. */
  299. BUG_ON(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL));
  300. ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres,
  301. OCFS2_LOCK_TYPE_META, 0, inode);
  302. }
  303. ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres,
  304. OCFS2_LOCK_TYPE_RW, inode->i_generation,
  305. inode);
  306. ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_data_lockres,
  307. OCFS2_LOCK_TYPE_DATA, inode->i_generation,
  308. inode);
  309. ocfs2_set_inode_flags(inode);
  310. inode->i_flags |= S_NOATIME;
  311. status = 0;
  312. bail:
  313. mlog_exit(status);
  314. return status;
  315. }
  316. static int ocfs2_read_locked_inode(struct inode *inode,
  317. struct ocfs2_find_inode_args *args)
  318. {
  319. struct super_block *sb;
  320. struct ocfs2_super *osb;
  321. struct ocfs2_dinode *fe;
  322. struct buffer_head *bh = NULL;
  323. int status, can_lock;
  324. u32 generation = 0;
  325. mlog_entry("(0x%p, 0x%p)\n", inode, args);
  326. status = -EINVAL;
  327. if (inode == NULL || inode->i_sb == NULL) {
  328. mlog(ML_ERROR, "bad inode\n");
  329. return status;
  330. }
  331. sb = inode->i_sb;
  332. osb = OCFS2_SB(sb);
  333. if (!args) {
  334. mlog(ML_ERROR, "bad inode args\n");
  335. make_bad_inode(inode);
  336. return status;
  337. }
  338. /*
  339. * To improve performance of cold-cache inode stats, we take
  340. * the cluster lock here if possible.
  341. *
  342. * Generally, OCFS2 never trusts the contents of an inode
  343. * unless it's holding a cluster lock, so taking it here isn't
  344. * a correctness issue as much as it is a performance
  345. * improvement.
  346. *
  347. * There are three times when taking the lock is not a good idea:
  348. *
  349. * 1) During startup, before we have initialized the DLM.
  350. *
  351. * 2) If we are reading certain system files which never get
  352. * cluster locks (local alloc, truncate log).
  353. *
  354. * 3) If the process doing the iget() is responsible for
  355. * orphan dir recovery. We're holding the orphan dir lock and
  356. * can get into a deadlock with another process on another
  357. * node in ->delete_inode().
  358. *
  359. * #1 and #2 can be simply solved by never taking the lock
  360. * here for system files (which are the only type we read
  361. * during mount). It's a heavier approach, but our main
  362. * concern is user-accesible files anyway.
  363. *
  364. * #3 works itself out because we'll eventually take the
  365. * cluster lock before trusting anything anyway.
  366. */
  367. can_lock = !(args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
  368. && !(args->fi_flags & OCFS2_FI_FLAG_NOLOCK);
  369. /*
  370. * To maintain backwards compatibility with older versions of
  371. * ocfs2-tools, we still store the generation value for system
  372. * files. The only ones that actually matter to userspace are
  373. * the journals, but it's easier and inexpensive to just flag
  374. * all system files similarly.
  375. */
  376. if (args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
  377. generation = osb->fs_generation;
  378. ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres,
  379. OCFS2_LOCK_TYPE_META,
  380. generation, inode);
  381. if (can_lock) {
  382. status = ocfs2_meta_lock(inode, NULL, NULL, 0);
  383. if (status) {
  384. make_bad_inode(inode);
  385. mlog_errno(status);
  386. return status;
  387. }
  388. }
  389. status = ocfs2_read_block(osb, args->fi_blkno, &bh, 0,
  390. can_lock ? inode : NULL);
  391. if (status < 0) {
  392. mlog_errno(status);
  393. goto bail;
  394. }
  395. status = -EINVAL;
  396. fe = (struct ocfs2_dinode *) bh->b_data;
  397. if (!OCFS2_IS_VALID_DINODE(fe)) {
  398. mlog(ML_ERROR, "Invalid dinode #%llu: signature = %.*s\n",
  399. (unsigned long long)fe->i_blkno, 7, fe->i_signature);
  400. goto bail;
  401. }
  402. /*
  403. * This is a code bug. Right now the caller needs to
  404. * understand whether it is asking for a system file inode or
  405. * not so the proper lock names can be built.
  406. */
  407. mlog_bug_on_msg(!!(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) !=
  408. !!(args->fi_flags & OCFS2_FI_FLAG_SYSFILE),
  409. "Inode %llu: system file state is ambigous\n",
  410. (unsigned long long)args->fi_blkno);
  411. if (S_ISCHR(le16_to_cpu(fe->i_mode)) ||
  412. S_ISBLK(le16_to_cpu(fe->i_mode)))
  413. inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
  414. if (ocfs2_populate_inode(inode, fe, 0) < 0) {
  415. mlog(ML_ERROR, "populate failed! i_blkno=%llu, i_ino=%lu\n",
  416. (unsigned long long)fe->i_blkno, inode->i_ino);
  417. goto bail;
  418. }
  419. BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno));
  420. status = 0;
  421. bail:
  422. if (can_lock)
  423. ocfs2_meta_unlock(inode, 0);
  424. if (status < 0)
  425. make_bad_inode(inode);
  426. if (args && bh)
  427. brelse(bh);
  428. mlog_exit(status);
  429. return status;
  430. }
  431. void ocfs2_sync_blockdev(struct super_block *sb)
  432. {
  433. sync_blockdev(sb->s_bdev);
  434. }
  435. static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
  436. struct inode *inode,
  437. struct buffer_head *fe_bh)
  438. {
  439. int status = 0;
  440. struct ocfs2_journal_handle *handle = NULL;
  441. struct ocfs2_truncate_context *tc = NULL;
  442. struct ocfs2_dinode *fe;
  443. mlog_entry_void();
  444. fe = (struct ocfs2_dinode *) fe_bh->b_data;
  445. /* zero allocation, zero truncate :) */
  446. if (!fe->i_clusters)
  447. goto bail;
  448. handle = ocfs2_start_trans(osb, handle, OCFS2_INODE_UPDATE_CREDITS);
  449. if (IS_ERR(handle)) {
  450. status = PTR_ERR(handle);
  451. handle = NULL;
  452. mlog_errno(status);
  453. goto bail;
  454. }
  455. status = ocfs2_set_inode_size(handle, inode, fe_bh, 0ULL);
  456. if (status < 0) {
  457. mlog_errno(status);
  458. goto bail;
  459. }
  460. ocfs2_commit_trans(handle);
  461. handle = NULL;
  462. status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc);
  463. if (status < 0) {
  464. mlog_errno(status);
  465. goto bail;
  466. }
  467. status = ocfs2_commit_truncate(osb, inode, fe_bh, tc);
  468. if (status < 0) {
  469. mlog_errno(status);
  470. goto bail;
  471. }
  472. bail:
  473. if (handle)
  474. ocfs2_commit_trans(handle);
  475. mlog_exit(status);
  476. return status;
  477. }
  478. static int ocfs2_remove_inode(struct inode *inode,
  479. struct buffer_head *di_bh,
  480. struct inode *orphan_dir_inode,
  481. struct buffer_head *orphan_dir_bh)
  482. {
  483. int status;
  484. struct inode *inode_alloc_inode = NULL;
  485. struct buffer_head *inode_alloc_bh = NULL;
  486. struct ocfs2_journal_handle *handle;
  487. struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  488. struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
  489. inode_alloc_inode =
  490. ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
  491. le16_to_cpu(di->i_suballoc_slot));
  492. if (!inode_alloc_inode) {
  493. status = -EEXIST;
  494. mlog_errno(status);
  495. goto bail;
  496. }
  497. mutex_lock(&inode_alloc_inode->i_mutex);
  498. status = ocfs2_meta_lock(inode_alloc_inode, NULL, &inode_alloc_bh, 1);
  499. if (status < 0) {
  500. mutex_unlock(&inode_alloc_inode->i_mutex);
  501. mlog_errno(status);
  502. goto bail;
  503. }
  504. handle = ocfs2_start_trans(osb, NULL, OCFS2_DELETE_INODE_CREDITS);
  505. if (IS_ERR(handle)) {
  506. status = PTR_ERR(handle);
  507. mlog_errno(status);
  508. goto bail_unlock;
  509. }
  510. status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
  511. orphan_dir_bh);
  512. if (status < 0) {
  513. mlog_errno(status);
  514. goto bail_commit;
  515. }
  516. /* set the inodes dtime */
  517. status = ocfs2_journal_access(handle, inode, di_bh,
  518. OCFS2_JOURNAL_ACCESS_WRITE);
  519. if (status < 0) {
  520. mlog_errno(status);
  521. goto bail_commit;
  522. }
  523. di->i_dtime = cpu_to_le64(CURRENT_TIME.tv_sec);
  524. le32_and_cpu(&di->i_flags, ~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL));
  525. status = ocfs2_journal_dirty(handle, di_bh);
  526. if (status < 0) {
  527. mlog_errno(status);
  528. goto bail_commit;
  529. }
  530. ocfs2_remove_from_cache(inode, di_bh);
  531. status = ocfs2_free_dinode(handle, inode_alloc_inode,
  532. inode_alloc_bh, di);
  533. if (status < 0)
  534. mlog_errno(status);
  535. bail_commit:
  536. ocfs2_commit_trans(handle);
  537. bail_unlock:
  538. ocfs2_meta_unlock(inode_alloc_inode, 1);
  539. mutex_unlock(&inode_alloc_inode->i_mutex);
  540. brelse(inode_alloc_bh);
  541. bail:
  542. iput(inode_alloc_inode);
  543. return status;
  544. }
  545. /*
  546. * Serialize with orphan dir recovery. If the process doing
  547. * recovery on this orphan dir does an iget() with the dir
  548. * i_mutex held, we'll deadlock here. Instead we detect this
  549. * and exit early - recovery will wipe this inode for us.
  550. */
  551. static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb,
  552. int slot)
  553. {
  554. int ret = 0;
  555. spin_lock(&osb->osb_lock);
  556. if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) {
  557. mlog(0, "Recovery is happening on orphan dir %d, will skip "
  558. "this inode\n", slot);
  559. ret = -EDEADLK;
  560. goto out;
  561. }
  562. /* This signals to the orphan recovery process that it should
  563. * wait for us to handle the wipe. */
  564. osb->osb_orphan_wipes[slot]++;
  565. out:
  566. spin_unlock(&osb->osb_lock);
  567. return ret;
  568. }
  569. static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb,
  570. int slot)
  571. {
  572. spin_lock(&osb->osb_lock);
  573. osb->osb_orphan_wipes[slot]--;
  574. spin_unlock(&osb->osb_lock);
  575. wake_up(&osb->osb_wipe_event);
  576. }
  577. static int ocfs2_wipe_inode(struct inode *inode,
  578. struct buffer_head *di_bh)
  579. {
  580. int status, orphaned_slot;
  581. struct inode *orphan_dir_inode = NULL;
  582. struct buffer_head *orphan_dir_bh = NULL;
  583. struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  584. /* We've already voted on this so it should be readonly - no
  585. * spinlock needed. */
  586. orphaned_slot = OCFS2_I(inode)->ip_orphaned_slot;
  587. status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot);
  588. if (status)
  589. return status;
  590. orphan_dir_inode = ocfs2_get_system_file_inode(osb,
  591. ORPHAN_DIR_SYSTEM_INODE,
  592. orphaned_slot);
  593. if (!orphan_dir_inode) {
  594. status = -EEXIST;
  595. mlog_errno(status);
  596. goto bail;
  597. }
  598. /* Lock the orphan dir. The lock will be held for the entire
  599. * delete_inode operation. We do this now to avoid races with
  600. * recovery completion on other nodes. */
  601. mutex_lock(&orphan_dir_inode->i_mutex);
  602. status = ocfs2_meta_lock(orphan_dir_inode, NULL, &orphan_dir_bh, 1);
  603. if (status < 0) {
  604. mutex_unlock(&orphan_dir_inode->i_mutex);
  605. mlog_errno(status);
  606. goto bail;
  607. }
  608. /* we do this while holding the orphan dir lock because we
  609. * don't want recovery being run from another node to vote for
  610. * an inode delete on us -- this will result in two nodes
  611. * truncating the same file! */
  612. status = ocfs2_truncate_for_delete(osb, inode, di_bh);
  613. if (status < 0) {
  614. mlog_errno(status);
  615. goto bail_unlock_dir;
  616. }
  617. status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
  618. orphan_dir_bh);
  619. if (status < 0)
  620. mlog_errno(status);
  621. bail_unlock_dir:
  622. ocfs2_meta_unlock(orphan_dir_inode, 1);
  623. mutex_unlock(&orphan_dir_inode->i_mutex);
  624. brelse(orphan_dir_bh);
  625. bail:
  626. iput(orphan_dir_inode);
  627. ocfs2_signal_wipe_completion(osb, orphaned_slot);
  628. return status;
  629. }
  630. /* There is a series of simple checks that should be done before a
  631. * vote is even considered. Encapsulate those in this function. */
  632. static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
  633. {
  634. int ret = 0;
  635. struct ocfs2_inode_info *oi = OCFS2_I(inode);
  636. struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  637. /* We shouldn't be getting here for the root directory
  638. * inode.. */
  639. if (inode == osb->root_inode) {
  640. mlog(ML_ERROR, "Skipping delete of root inode.\n");
  641. goto bail;
  642. }
  643. /* If we're coming from process_vote we can't go into our own
  644. * voting [hello, deadlock city!], so unforuntately we just
  645. * have to skip deleting this guy. That's OK though because
  646. * the node who's doing the actual deleting should handle it
  647. * anyway. */
  648. if (current == osb->vote_task) {
  649. mlog(0, "Skipping delete of %lu because we're currently "
  650. "in process_vote\n", inode->i_ino);
  651. goto bail;
  652. }
  653. spin_lock(&oi->ip_lock);
  654. /* OCFS2 *never* deletes system files. This should technically
  655. * never get here as system file inodes should always have a
  656. * positive link count. */
  657. if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
  658. mlog(ML_ERROR, "Skipping delete of system file %llu\n",
  659. (unsigned long long)oi->ip_blkno);
  660. goto bail_unlock;
  661. }
  662. /* If we have voted "yes" on the wipe of this inode for
  663. * another node, it will be marked here so we can safely skip
  664. * it. Recovery will cleanup any inodes we might inadvertantly
  665. * skip here. */
  666. if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) {
  667. mlog(0, "Skipping delete of %lu because another node "
  668. "has done this for us.\n", inode->i_ino);
  669. goto bail_unlock;
  670. }
  671. ret = 1;
  672. bail_unlock:
  673. spin_unlock(&oi->ip_lock);
  674. bail:
  675. return ret;
  676. }
  677. /* Query the cluster to determine whether we should wipe an inode from
  678. * disk or not.
  679. *
  680. * Requires the inode to have the cluster lock. */
  681. static int ocfs2_query_inode_wipe(struct inode *inode,
  682. struct buffer_head *di_bh,
  683. int *wipe)
  684. {
  685. int status = 0;
  686. struct ocfs2_inode_info *oi = OCFS2_I(inode);
  687. struct ocfs2_dinode *di;
  688. *wipe = 0;
  689. /* While we were waiting for the cluster lock in
  690. * ocfs2_delete_inode, another node might have asked to delete
  691. * the inode. Recheck our flags to catch this. */
  692. if (!ocfs2_inode_is_valid_to_delete(inode)) {
  693. mlog(0, "Skipping delete of %llu because flags changed\n",
  694. (unsigned long long)oi->ip_blkno);
  695. goto bail;
  696. }
  697. /* Now that we have an up to date inode, we can double check
  698. * the link count. */
  699. if (inode->i_nlink) {
  700. mlog(0, "Skipping delete of %llu because nlink = %u\n",
  701. (unsigned long long)oi->ip_blkno, inode->i_nlink);
  702. goto bail;
  703. }
  704. /* Do some basic inode verification... */
  705. di = (struct ocfs2_dinode *) di_bh->b_data;
  706. if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL))) {
  707. /* for lack of a better error? */
  708. status = -EEXIST;
  709. mlog(ML_ERROR,
  710. "Inode %llu (on-disk %llu) not orphaned! "
  711. "Disk flags 0x%x, inode flags 0x%x\n",
  712. (unsigned long long)oi->ip_blkno,
  713. (unsigned long long)di->i_blkno, di->i_flags,
  714. oi->ip_flags);
  715. goto bail;
  716. }
  717. /* has someone already deleted us?! baaad... */
  718. if (di->i_dtime) {
  719. status = -EEXIST;
  720. mlog_errno(status);
  721. goto bail;
  722. }
  723. status = ocfs2_request_delete_vote(inode);
  724. /* -EBUSY means that other nodes are still using the
  725. * inode. We're done here though, so avoid doing anything on
  726. * disk and let them worry about deleting it. */
  727. if (status == -EBUSY) {
  728. status = 0;
  729. mlog(0, "Skipping delete of %llu because it is in use on"
  730. "other nodes\n", (unsigned long long)oi->ip_blkno);
  731. goto bail;
  732. }
  733. if (status < 0) {
  734. mlog_errno(status);
  735. goto bail;
  736. }
  737. spin_lock(&oi->ip_lock);
  738. if (oi->ip_orphaned_slot == OCFS2_INVALID_SLOT) {
  739. /* Nobody knew which slot this inode was orphaned
  740. * into. This may happen during node death and
  741. * recovery knows how to clean it up so we can safely
  742. * ignore this inode for now on. */
  743. mlog(0, "Nobody knew where inode %llu was orphaned!\n",
  744. (unsigned long long)oi->ip_blkno);
  745. } else {
  746. *wipe = 1;
  747. mlog(0, "Inode %llu is ok to wipe from orphan dir %d\n",
  748. (unsigned long long)oi->ip_blkno, oi->ip_orphaned_slot);
  749. }
  750. spin_unlock(&oi->ip_lock);
  751. bail:
  752. return status;
  753. }
  754. /* Support function for ocfs2_delete_inode. Will help us keep the
  755. * inode data in a consistent state for clear_inode. Always truncates
  756. * pages, optionally sync's them first. */
  757. static void ocfs2_cleanup_delete_inode(struct inode *inode,
  758. int sync_data)
  759. {
  760. mlog(0, "Cleanup inode %llu, sync = %d\n",
  761. (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data);
  762. if (sync_data)
  763. write_inode_now(inode, 1);
  764. truncate_inode_pages(&inode->i_data, 0);
  765. }
  766. void ocfs2_delete_inode(struct inode *inode)
  767. {
  768. int wipe, status;
  769. sigset_t blocked, oldset;
  770. struct buffer_head *di_bh = NULL;
  771. mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
  772. if (is_bad_inode(inode)) {
  773. mlog(0, "Skipping delete of bad inode\n");
  774. goto bail;
  775. }
  776. if (!ocfs2_inode_is_valid_to_delete(inode)) {
  777. /* It's probably not necessary to truncate_inode_pages
  778. * here but we do it for safety anyway (it will most
  779. * likely be a no-op anyway) */
  780. ocfs2_cleanup_delete_inode(inode, 0);
  781. goto bail;
  782. }
  783. /* We want to block signals in delete_inode as the lock and
  784. * messaging paths may return us -ERESTARTSYS. Which would
  785. * cause us to exit early, resulting in inodes being orphaned
  786. * forever. */
  787. sigfillset(&blocked);
  788. status = sigprocmask(SIG_BLOCK, &blocked, &oldset);
  789. if (status < 0) {
  790. mlog_errno(status);
  791. ocfs2_cleanup_delete_inode(inode, 1);
  792. goto bail;
  793. }
  794. /* Lock down the inode. This gives us an up to date view of
  795. * it's metadata (for verification), and allows us to
  796. * serialize delete_inode votes.
  797. *
  798. * Even though we might be doing a truncate, we don't take the
  799. * allocation lock here as it won't be needed - nobody will
  800. * have the file open.
  801. */
  802. status = ocfs2_meta_lock(inode, NULL, &di_bh, 1);
  803. if (status < 0) {
  804. if (status != -ENOENT)
  805. mlog_errno(status);
  806. ocfs2_cleanup_delete_inode(inode, 0);
  807. goto bail_unblock;
  808. }
  809. /* Query the cluster. This will be the final decision made
  810. * before we go ahead and wipe the inode. */
  811. status = ocfs2_query_inode_wipe(inode, di_bh, &wipe);
  812. if (!wipe || status < 0) {
  813. /* Error and inode busy vote both mean we won't be
  814. * removing the inode, so they take almost the same
  815. * path. */
  816. if (status < 0)
  817. mlog_errno(status);
  818. /* Someone in the cluster has voted to not wipe this
  819. * inode, or it was never completely orphaned. Write
  820. * out the pages and exit now. */
  821. ocfs2_cleanup_delete_inode(inode, 1);
  822. goto bail_unlock_inode;
  823. }
  824. ocfs2_cleanup_delete_inode(inode, 0);
  825. status = ocfs2_wipe_inode(inode, di_bh);
  826. if (status < 0) {
  827. if (status != -EDEADLK)
  828. mlog_errno(status);
  829. goto bail_unlock_inode;
  830. }
  831. /*
  832. * Mark the inode as successfully deleted.
  833. *
  834. * This is important for ocfs2_clear_inode() as it will check
  835. * this flag and skip any checkpointing work
  836. *
  837. * ocfs2_stuff_meta_lvb() also uses this flag to invalidate
  838. * the LVB for other nodes.
  839. */
  840. OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED;
  841. bail_unlock_inode:
  842. ocfs2_meta_unlock(inode, 1);
  843. brelse(di_bh);
  844. bail_unblock:
  845. status = sigprocmask(SIG_SETMASK, &oldset, NULL);
  846. if (status < 0)
  847. mlog_errno(status);
  848. bail:
  849. clear_inode(inode);
  850. mlog_exit_void();
  851. }
  852. void ocfs2_clear_inode(struct inode *inode)
  853. {
  854. int status;
  855. struct ocfs2_inode_info *oi = OCFS2_I(inode);
  856. mlog_entry_void();
  857. if (!inode)
  858. goto bail;
  859. mlog(0, "Clearing inode: %llu, nlink = %u\n",
  860. (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_nlink);
  861. mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL,
  862. "Inode=%lu\n", inode->i_ino);
  863. /* Do these before all the other work so that we don't bounce
  864. * the vote thread while waiting to destroy the locks. */
  865. ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres);
  866. ocfs2_mark_lockres_freeing(&oi->ip_meta_lockres);
  867. ocfs2_mark_lockres_freeing(&oi->ip_data_lockres);
  868. /* We very well may get a clear_inode before all an inodes
  869. * metadata has hit disk. Of course, we can't drop any cluster
  870. * locks until the journal has finished with it. The only
  871. * exception here are successfully wiped inodes - their
  872. * metadata can now be considered to be part of the system
  873. * inodes from which it came. */
  874. if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED))
  875. ocfs2_checkpoint_inode(inode);
  876. mlog_bug_on_msg(!list_empty(&oi->ip_io_markers),
  877. "Clear inode of %llu, inode has io markers\n",
  878. (unsigned long long)oi->ip_blkno);
  879. ocfs2_extent_map_drop(inode, 0);
  880. ocfs2_extent_map_init(inode);
  881. status = ocfs2_drop_inode_locks(inode);
  882. if (status < 0)
  883. mlog_errno(status);
  884. ocfs2_lock_res_free(&oi->ip_rw_lockres);
  885. ocfs2_lock_res_free(&oi->ip_meta_lockres);
  886. ocfs2_lock_res_free(&oi->ip_data_lockres);
  887. ocfs2_metadata_cache_purge(inode);
  888. mlog_bug_on_msg(oi->ip_metadata_cache.ci_num_cached,
  889. "Clear inode of %llu, inode has %u cache items\n",
  890. (unsigned long long)oi->ip_blkno, oi->ip_metadata_cache.ci_num_cached);
  891. mlog_bug_on_msg(!(oi->ip_flags & OCFS2_INODE_CACHE_INLINE),
  892. "Clear inode of %llu, inode has a bad flag\n",
  893. (unsigned long long)oi->ip_blkno);
  894. mlog_bug_on_msg(spin_is_locked(&oi->ip_lock),
  895. "Clear inode of %llu, inode is locked\n",
  896. (unsigned long long)oi->ip_blkno);
  897. mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex),
  898. "Clear inode of %llu, io_mutex is locked\n",
  899. (unsigned long long)oi->ip_blkno);
  900. mutex_unlock(&oi->ip_io_mutex);
  901. /*
  902. * down_trylock() returns 0, down_write_trylock() returns 1
  903. * kernel 1, world 0
  904. */
  905. mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem),
  906. "Clear inode of %llu, alloc_sem is locked\n",
  907. (unsigned long long)oi->ip_blkno);
  908. up_write(&oi->ip_alloc_sem);
  909. mlog_bug_on_msg(oi->ip_open_count,
  910. "Clear inode of %llu has open count %d\n",
  911. (unsigned long long)oi->ip_blkno, oi->ip_open_count);
  912. mlog_bug_on_msg(!list_empty(&oi->ip_handle_list),
  913. "Clear inode of %llu has non empty handle list\n",
  914. (unsigned long long)oi->ip_blkno);
  915. mlog_bug_on_msg(oi->ip_handle,
  916. "Clear inode of %llu has non empty handle pointer\n",
  917. (unsigned long long)oi->ip_blkno);
  918. /* Clear all other flags. */
  919. oi->ip_flags = OCFS2_INODE_CACHE_INLINE;
  920. oi->ip_created_trans = 0;
  921. oi->ip_last_trans = 0;
  922. oi->ip_dir_start_lookup = 0;
  923. oi->ip_blkno = 0ULL;
  924. bail:
  925. mlog_exit_void();
  926. }
  927. /* Called under inode_lock, with no more references on the
  928. * struct inode, so it's safe here to check the flags field
  929. * and to manipulate i_nlink without any other locks. */
  930. void ocfs2_drop_inode(struct inode *inode)
  931. {
  932. struct ocfs2_inode_info *oi = OCFS2_I(inode);
  933. mlog_entry_void();
  934. mlog(0, "Drop inode %llu, nlink = %u, ip_flags = 0x%x\n",
  935. (unsigned long long)oi->ip_blkno, inode->i_nlink, oi->ip_flags);
  936. /* Testing ip_orphaned_slot here wouldn't work because we may
  937. * not have gotten a delete_inode vote from any other nodes
  938. * yet. */
  939. if (oi->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)
  940. generic_delete_inode(inode);
  941. else
  942. generic_drop_inode(inode);
  943. mlog_exit_void();
  944. }
  945. /*
  946. * TODO: this should probably be merged into ocfs2_get_block
  947. *
  948. * However, you now need to pay attention to the cont_prepare_write()
  949. * stuff in ocfs2_get_block (that is, ocfs2_get_block pretty much
  950. * expects never to extend).
  951. */
  952. struct buffer_head *ocfs2_bread(struct inode *inode,
  953. int block, int *err, int reada)
  954. {
  955. struct buffer_head *bh = NULL;
  956. int tmperr;
  957. u64 p_blkno;
  958. int readflags = OCFS2_BH_CACHED;
  959. if (reada)
  960. readflags |= OCFS2_BH_READAHEAD;
  961. if (((u64)block << inode->i_sb->s_blocksize_bits) >=
  962. i_size_read(inode)) {
  963. BUG_ON(!reada);
  964. return NULL;
  965. }
  966. tmperr = ocfs2_extent_map_get_blocks(inode, block, 1,
  967. &p_blkno, NULL);
  968. if (tmperr < 0) {
  969. mlog_errno(tmperr);
  970. goto fail;
  971. }
  972. tmperr = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno, &bh,
  973. readflags, inode);
  974. if (tmperr < 0)
  975. goto fail;
  976. tmperr = 0;
  977. *err = 0;
  978. return bh;
  979. fail:
  980. if (bh) {
  981. brelse(bh);
  982. bh = NULL;
  983. }
  984. *err = -EIO;
  985. return NULL;
  986. }
  987. /*
  988. * This is called from our getattr.
  989. */
  990. int ocfs2_inode_revalidate(struct dentry *dentry)
  991. {
  992. struct inode *inode = dentry->d_inode;
  993. int status = 0;
  994. mlog_entry("(inode = 0x%p, ino = %llu)\n", inode,
  995. inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL);
  996. if (!inode) {
  997. mlog(0, "eep, no inode!\n");
  998. status = -ENOENT;
  999. goto bail;
  1000. }
  1001. spin_lock(&OCFS2_I(inode)->ip_lock);
  1002. if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
  1003. spin_unlock(&OCFS2_I(inode)->ip_lock);
  1004. mlog(0, "inode deleted!\n");
  1005. status = -ENOENT;
  1006. goto bail;
  1007. }
  1008. spin_unlock(&OCFS2_I(inode)->ip_lock);
  1009. /* Let ocfs2_meta_lock do the work of updating our struct
  1010. * inode for us. */
  1011. status = ocfs2_meta_lock(inode, NULL, NULL, 0);
  1012. if (status < 0) {
  1013. if (status != -ENOENT)
  1014. mlog_errno(status);
  1015. goto bail;
  1016. }
  1017. ocfs2_meta_unlock(inode, 0);
  1018. bail:
  1019. mlog_exit(status);
  1020. return status;
  1021. }
  1022. /*
  1023. * Updates a disk inode from a
  1024. * struct inode.
  1025. * Only takes ip_lock.
  1026. */
  1027. int ocfs2_mark_inode_dirty(struct ocfs2_journal_handle *handle,
  1028. struct inode *inode,
  1029. struct buffer_head *bh)
  1030. {
  1031. int status;
  1032. struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
  1033. mlog_entry("(inode %llu)\n",
  1034. (unsigned long long)OCFS2_I(inode)->ip_blkno);
  1035. status = ocfs2_journal_access(handle, inode, bh,
  1036. OCFS2_JOURNAL_ACCESS_WRITE);
  1037. if (status < 0) {
  1038. mlog_errno(status);
  1039. goto leave;
  1040. }
  1041. spin_lock(&OCFS2_I(inode)->ip_lock);
  1042. fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
  1043. fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr);
  1044. spin_unlock(&OCFS2_I(inode)->ip_lock);
  1045. fe->i_size = cpu_to_le64(i_size_read(inode));
  1046. fe->i_links_count = cpu_to_le16(inode->i_nlink);
  1047. fe->i_uid = cpu_to_le32(inode->i_uid);
  1048. fe->i_gid = cpu_to_le32(inode->i_gid);
  1049. fe->i_mode = cpu_to_le16(inode->i_mode);
  1050. fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
  1051. fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
  1052. fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
  1053. fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
  1054. fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
  1055. fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
  1056. status = ocfs2_journal_dirty(handle, bh);
  1057. if (status < 0)
  1058. mlog_errno(status);
  1059. status = 0;
  1060. leave:
  1061. mlog_exit(status);
  1062. return status;
  1063. }
  1064. /*
  1065. *
  1066. * Updates a struct inode from a disk inode.
  1067. * does no i/o, only takes ip_lock.
  1068. */
  1069. void ocfs2_refresh_inode(struct inode *inode,
  1070. struct ocfs2_dinode *fe)
  1071. {
  1072. struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  1073. spin_lock(&OCFS2_I(inode)->ip_lock);
  1074. OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
  1075. OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
  1076. ocfs2_set_inode_flags(inode);
  1077. i_size_write(inode, le64_to_cpu(fe->i_size));
  1078. inode->i_nlink = le16_to_cpu(fe->i_links_count);
  1079. inode->i_uid = le32_to_cpu(fe->i_uid);
  1080. inode->i_gid = le32_to_cpu(fe->i_gid);
  1081. inode->i_mode = le16_to_cpu(fe->i_mode);
  1082. inode->i_blksize = (u32) osb->s_clustersize;
  1083. if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0)
  1084. inode->i_blocks = 0;
  1085. else
  1086. inode->i_blocks = ocfs2_align_bytes_to_sectors(i_size_read(inode));
  1087. inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
  1088. inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
  1089. inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
  1090. inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
  1091. inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
  1092. inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
  1093. spin_unlock(&OCFS2_I(inode)->ip_lock);
  1094. }