17336d0e6SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2b3b94faaSDavid Teigland /* 3b3b94faaSDavid Teigland * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4da6dd40dSBob Peterson * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. 5b3b94faaSDavid Teigland */ 6b3b94faaSDavid Teigland 7d77d1b58SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8d77d1b58SJoe Perches 99e6e0a12SSteven Whitehouse #include <linux/bio.h> 10174cd4b1SIngo Molnar #include <linux/sched/signal.h> 11b3b94faaSDavid Teigland #include <linux/slab.h> 12b3b94faaSDavid Teigland #include <linux/spinlock.h> 13b3b94faaSDavid Teigland #include <linux/completion.h> 14b3b94faaSDavid Teigland #include <linux/buffer_head.h> 159e6e0a12SSteven Whitehouse #include <linux/statfs.h> 169e6e0a12SSteven Whitehouse #include <linux/seq_file.h> 179e6e0a12SSteven Whitehouse #include <linux/mount.h> 189e6e0a12SSteven Whitehouse #include <linux/kthread.h> 199e6e0a12SSteven Whitehouse #include <linux/delay.h> 205c676f6dSSteven Whitehouse #include <linux/gfs2_ondisk.h> 219e6e0a12SSteven Whitehouse #include <linux/crc32.h> 229e6e0a12SSteven Whitehouse #include <linux/time.h> 23e402746aSSteven Whitehouse #include <linux/wait.h> 24a9185b41SChristoph Hellwig #include <linux/writeback.h> 254667a0ecSSteven Whitehouse #include <linux/backing-dev.h> 262e60d768SBenjamin Marzinski #include <linux/kernel.h> 27b3b94faaSDavid Teigland 28b3b94faaSDavid Teigland #include "gfs2.h" 295c676f6dSSteven Whitehouse #include "incore.h" 30b3b94faaSDavid Teigland #include "bmap.h" 31b3b94faaSDavid Teigland #include "dir.h" 32b3b94faaSDavid Teigland #include "glock.h" 33b3b94faaSDavid Teigland #include "glops.h" 34b3b94faaSDavid Teigland #include "inode.h" 35b3b94faaSDavid Teigland #include "log.h" 36b3b94faaSDavid Teigland #include "meta_io.h" 37b3b94faaSDavid Teigland #include "quota.h" 38b3b94faaSDavid Teigland #include "recovery.h" 39b3b94faaSDavid Teigland #include "rgrp.h" 40b3b94faaSDavid Teigland #include "super.h" 41b3b94faaSDavid Teigland #include "trans.h" 425c676f6dSSteven Whitehouse #include "util.h" 439e6e0a12SSteven Whitehouse #include "sys.h" 44307cf6e6SSteven Whitehouse #include "xattr.h" 45f4686c26SAbhi Das #include "lops.h" 469e6e0a12SSteven Whitehouse 47fefc03bfSSteven Whitehouse /** 48fefc03bfSSteven Whitehouse * gfs2_jindex_free - Clear all the journal index information 49fefc03bfSSteven Whitehouse * @sdp: The GFS2 superblock 50fefc03bfSSteven Whitehouse * 51fefc03bfSSteven Whitehouse */ 52fefc03bfSSteven Whitehouse 53fefc03bfSSteven Whitehouse void gfs2_jindex_free(struct gfs2_sbd *sdp) 54fefc03bfSSteven Whitehouse { 55b50f227bSSteven Whitehouse struct list_head list; 56fefc03bfSSteven Whitehouse struct gfs2_jdesc *jd; 57fefc03bfSSteven Whitehouse 58fefc03bfSSteven Whitehouse spin_lock(&sdp->sd_jindex_spin); 59fefc03bfSSteven Whitehouse list_add(&list, &sdp->sd_jindex_list); 60fefc03bfSSteven Whitehouse list_del_init(&sdp->sd_jindex_list); 61fefc03bfSSteven Whitehouse sdp->sd_journals = 0; 62fefc03bfSSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 63fefc03bfSSteven Whitehouse 64601ef0d5SBob Peterson sdp->sd_jdesc = NULL; 65fefc03bfSSteven Whitehouse while (!list_empty(&list)) { 66969183bcSAndreas Gruenbacher jd = list_first_entry(&list, struct gfs2_jdesc, jd_list); 67b50f227bSSteven Whitehouse gfs2_free_journal_extents(jd); 68fefc03bfSSteven Whitehouse list_del(&jd->jd_list); 69fefc03bfSSteven Whitehouse iput(jd->jd_inode); 70601ef0d5SBob Peterson jd->jd_inode = NULL; 71fefc03bfSSteven Whitehouse kfree(jd); 72fefc03bfSSteven Whitehouse } 73fefc03bfSSteven Whitehouse } 74fefc03bfSSteven Whitehouse 75b3b94faaSDavid Teigland static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid) 76b3b94faaSDavid Teigland { 77b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 78b3b94faaSDavid Teigland int found = 0; 79b3b94faaSDavid Teigland 80b3b94faaSDavid Teigland list_for_each_entry(jd, head, jd_list) { 81b3b94faaSDavid Teigland if (jd->jd_jid == jid) { 82b3b94faaSDavid Teigland found = 1; 83b3b94faaSDavid Teigland break; 84b3b94faaSDavid Teigland } 85b3b94faaSDavid Teigland } 86b3b94faaSDavid Teigland 87b3b94faaSDavid Teigland if (!found) 88b3b94faaSDavid Teigland jd = NULL; 89b3b94faaSDavid Teigland 90b3b94faaSDavid Teigland return jd; 91b3b94faaSDavid Teigland } 92b3b94faaSDavid Teigland 93b3b94faaSDavid Teigland struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid) 94b3b94faaSDavid Teigland { 95b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 96b3b94faaSDavid Teigland 97b3b94faaSDavid Teigland spin_lock(&sdp->sd_jindex_spin); 98b3b94faaSDavid Teigland jd = jdesc_find_i(&sdp->sd_jindex_list, jid); 99b3b94faaSDavid Teigland spin_unlock(&sdp->sd_jindex_spin); 100b3b94faaSDavid Teigland 101b3b94faaSDavid Teigland return jd; 102b3b94faaSDavid Teigland } 103b3b94faaSDavid Teigland 104b3b94faaSDavid Teigland int gfs2_jdesc_check(struct gfs2_jdesc *jd) 105b3b94faaSDavid Teigland { 106feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 107feaa7bbaSSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 108a2e0f799SSteven Whitehouse u64 size = i_size_read(jd->jd_inode); 109b3b94faaSDavid Teigland 11047a9a527SFabian Frederick if (gfs2_check_internal_file_size(jd->jd_inode, 8 << 20, BIT(30))) 111b3b94faaSDavid Teigland return -EIO; 112b3b94faaSDavid Teigland 113a2e0f799SSteven Whitehouse jd->jd_blocks = size >> sdp->sd_sb.sb_bsize_shift; 114a2e0f799SSteven Whitehouse 115a2e0f799SSteven Whitehouse if (gfs2_write_alloc_required(ip, 0, size)) { 116b3b94faaSDavid Teigland gfs2_consist_inode(ip); 117461cb419SBob Peterson return -EIO; 118b3b94faaSDavid Teigland } 119b3b94faaSDavid Teigland 120461cb419SBob Peterson return 0; 121b3b94faaSDavid Teigland } 122b3b94faaSDavid Teigland 1238ad151c2SSteven Whitehouse static int init_threads(struct gfs2_sbd *sdp) 1248ad151c2SSteven Whitehouse { 1258ad151c2SSteven Whitehouse struct task_struct *p; 1268ad151c2SSteven Whitehouse int error = 0; 1278ad151c2SSteven Whitehouse 1288ad151c2SSteven Whitehouse p = kthread_run(gfs2_logd, sdp, "gfs2_logd"); 1298ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1308ad151c2SSteven Whitehouse error = PTR_ERR(p); 1318ad151c2SSteven Whitehouse fs_err(sdp, "can't start logd thread: %d\n", error); 1328ad151c2SSteven Whitehouse return error; 1338ad151c2SSteven Whitehouse } 1348ad151c2SSteven Whitehouse sdp->sd_logd_process = p; 1358ad151c2SSteven Whitehouse 1368ad151c2SSteven Whitehouse p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad"); 1378ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1388ad151c2SSteven Whitehouse error = PTR_ERR(p); 1398ad151c2SSteven Whitehouse fs_err(sdp, "can't start quotad thread: %d\n", error); 1408ad151c2SSteven Whitehouse goto fail; 1418ad151c2SSteven Whitehouse } 1428ad151c2SSteven Whitehouse sdp->sd_quotad_process = p; 1438ad151c2SSteven Whitehouse return 0; 1448ad151c2SSteven Whitehouse 1458ad151c2SSteven Whitehouse fail: 1468ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 1475b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 1488ad151c2SSteven Whitehouse return error; 1498ad151c2SSteven Whitehouse } 1508ad151c2SSteven Whitehouse 151b3b94faaSDavid Teigland /** 152b3b94faaSDavid Teigland * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one 153b3b94faaSDavid Teigland * @sdp: the filesystem 154b3b94faaSDavid Teigland * 155b3b94faaSDavid Teigland * Returns: errno 156b3b94faaSDavid Teigland */ 157b3b94faaSDavid Teigland 158b3b94faaSDavid Teigland int gfs2_make_fs_rw(struct gfs2_sbd *sdp) 159b3b94faaSDavid Teigland { 160feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 1615c676f6dSSteven Whitehouse struct gfs2_glock *j_gl = ip->i_gl; 1622e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 16355167622SAl Viro struct gfs2_log_header_host head; 164b3b94faaSDavid Teigland int error; 165b3b94faaSDavid Teigland 1668ad151c2SSteven Whitehouse error = init_threads(sdp); 167b3b94faaSDavid Teigland if (error) 168b3b94faaSDavid Teigland return error; 169b3b94faaSDavid Teigland 17024972557SBenjamin Marzinski error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 0, 1712e60d768SBenjamin Marzinski &freeze_gh); 1728ad151c2SSteven Whitehouse if (error) 1738ad151c2SSteven Whitehouse goto fail_threads; 1748ad151c2SSteven Whitehouse 1751a14d3a6SSteven Whitehouse j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 176601ef0d5SBob Peterson if (gfs2_withdrawn(sdp)) { 177601ef0d5SBob Peterson error = -EIO; 178601ef0d5SBob Peterson goto fail; 179601ef0d5SBob Peterson } 180b3b94faaSDavid Teigland 181f4686c26SAbhi Das error = gfs2_find_jhead(sdp->sd_jdesc, &head, false); 182601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 183b3b94faaSDavid Teigland goto fail; 184b3b94faaSDavid Teigland 185b3b94faaSDavid Teigland if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 186b3b94faaSDavid Teigland gfs2_consist(sdp); 187b3b94faaSDavid Teigland error = -EIO; 188b3b94faaSDavid Teigland goto fail; 189b3b94faaSDavid Teigland } 190b3b94faaSDavid Teigland 191b3b94faaSDavid Teigland /* Initialize some head of the log stuff */ 192b3b94faaSDavid Teigland sdp->sd_log_sequence = head.lh_sequence + 1; 193b3b94faaSDavid Teigland gfs2_log_pointers_init(sdp, head.lh_blkno); 194b3b94faaSDavid Teigland 195b3b94faaSDavid Teigland error = gfs2_quota_init(sdp); 196601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 197a91ea69fSSteven Whitehouse goto fail; 198b3b94faaSDavid Teigland 199b3b94faaSDavid Teigland set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 200b3b94faaSDavid Teigland 2012e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 202b3b94faaSDavid Teigland 203b3b94faaSDavid Teigland return 0; 204b3b94faaSDavid Teigland 205b3b94faaSDavid Teigland fail: 2062e60d768SBenjamin Marzinski freeze_gh.gh_flags |= GL_NOCACHE; 2072e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 2088ad151c2SSteven Whitehouse fail_threads: 2095b3a9f34SBob Peterson if (sdp->sd_quotad_process) 2108ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 2115b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 2125b3a9f34SBob Peterson if (sdp->sd_logd_process) 2138ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 2145b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 215b3b94faaSDavid Teigland return error; 216b3b94faaSDavid Teigland } 217b3b94faaSDavid Teigland 2181946f70aSBenjamin Marzinski void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf) 219bb8d8a6fSSteven Whitehouse { 220bb8d8a6fSSteven Whitehouse const struct gfs2_statfs_change *str = buf; 221bb8d8a6fSSteven Whitehouse 222bb8d8a6fSSteven Whitehouse sc->sc_total = be64_to_cpu(str->sc_total); 223bb8d8a6fSSteven Whitehouse sc->sc_free = be64_to_cpu(str->sc_free); 224bb8d8a6fSSteven Whitehouse sc->sc_dinodes = be64_to_cpu(str->sc_dinodes); 225bb8d8a6fSSteven Whitehouse } 226bb8d8a6fSSteven Whitehouse 227bb8d8a6fSSteven Whitehouse static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf) 228bb8d8a6fSSteven Whitehouse { 229bb8d8a6fSSteven Whitehouse struct gfs2_statfs_change *str = buf; 230bb8d8a6fSSteven Whitehouse 231bb8d8a6fSSteven Whitehouse str->sc_total = cpu_to_be64(sc->sc_total); 232bb8d8a6fSSteven Whitehouse str->sc_free = cpu_to_be64(sc->sc_free); 233bb8d8a6fSSteven Whitehouse str->sc_dinodes = cpu_to_be64(sc->sc_dinodes); 234bb8d8a6fSSteven Whitehouse } 235bb8d8a6fSSteven Whitehouse 236b3b94faaSDavid Teigland int gfs2_statfs_init(struct gfs2_sbd *sdp) 237b3b94faaSDavid Teigland { 238feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 239bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 240feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 241bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 242b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 243b3b94faaSDavid Teigland struct gfs2_holder gh; 244b3b94faaSDavid Teigland int error; 245b3b94faaSDavid Teigland 246b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 247b3b94faaSDavid Teigland &gh); 248b3b94faaSDavid Teigland if (error) 249b3b94faaSDavid Teigland return error; 250b3b94faaSDavid Teigland 251b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 252b3b94faaSDavid Teigland if (error) 253b3b94faaSDavid Teigland goto out; 254b3b94faaSDavid Teigland 255b3b94faaSDavid Teigland if (sdp->sd_args.ar_spectator) { 256b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 257b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 258b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 259b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 260b3b94faaSDavid Teigland } else { 261b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 262b3b94faaSDavid Teigland if (error) 263b3b94faaSDavid Teigland goto out_m_bh; 264b3b94faaSDavid Teigland 265b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 266b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 267b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 268b3b94faaSDavid Teigland gfs2_statfs_change_in(l_sc, l_bh->b_data + 269b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 270b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 271b3b94faaSDavid Teigland 272b3b94faaSDavid Teigland brelse(l_bh); 273b3b94faaSDavid Teigland } 274b3b94faaSDavid Teigland 275b3b94faaSDavid Teigland out_m_bh: 276b3b94faaSDavid Teigland brelse(m_bh); 277b3b94faaSDavid Teigland out: 278b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 279b3b94faaSDavid Teigland return 0; 280b3b94faaSDavid Teigland } 281b3b94faaSDavid Teigland 282cd915493SSteven Whitehouse void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free, 283cd915493SSteven Whitehouse s64 dinodes) 284b3b94faaSDavid Teigland { 285feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 286bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 2873d3c10f2SBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 288b3b94faaSDavid Teigland struct buffer_head *l_bh; 289c14f5735SBenjamin Marzinski s64 x, y; 290c14f5735SBenjamin Marzinski int need_sync = 0; 291b3b94faaSDavid Teigland int error; 292b3b94faaSDavid Teigland 293b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 294b3b94faaSDavid Teigland if (error) 295b3b94faaSDavid Teigland return; 296b3b94faaSDavid Teigland 297350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 298b3b94faaSDavid Teigland 299b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 300b3b94faaSDavid Teigland l_sc->sc_total += total; 301b3b94faaSDavid Teigland l_sc->sc_free += free; 302b3b94faaSDavid Teigland l_sc->sc_dinodes += dinodes; 303907b9bceSSteven Whitehouse gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode)); 304c14f5735SBenjamin Marzinski if (sdp->sd_args.ar_statfs_percent) { 305c14f5735SBenjamin Marzinski x = 100 * l_sc->sc_free; 306c14f5735SBenjamin Marzinski y = m_sc->sc_free * sdp->sd_args.ar_statfs_percent; 307c14f5735SBenjamin Marzinski if (x >= y || x <= -y) 308c14f5735SBenjamin Marzinski need_sync = 1; 309c14f5735SBenjamin Marzinski } 310b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 311b3b94faaSDavid Teigland 312b3b94faaSDavid Teigland brelse(l_bh); 313c14f5735SBenjamin Marzinski if (need_sync) 3143d3c10f2SBenjamin Marzinski gfs2_wake_up_statfs(sdp); 315b3b94faaSDavid Teigland } 316b3b94faaSDavid Teigland 3171946f70aSBenjamin Marzinski void update_statfs(struct gfs2_sbd *sdp, struct buffer_head *m_bh, 3181946f70aSBenjamin Marzinski struct buffer_head *l_bh) 3191946f70aSBenjamin Marzinski { 3201946f70aSBenjamin Marzinski struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 3211946f70aSBenjamin Marzinski struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 3221946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 3231946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 3241946f70aSBenjamin Marzinski 325350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 326901c6c66SBob Peterson gfs2_trans_add_meta(m_ip->i_gl, m_bh); 3271946f70aSBenjamin Marzinski 3281946f70aSBenjamin Marzinski spin_lock(&sdp->sd_statfs_spin); 3291946f70aSBenjamin Marzinski m_sc->sc_total += l_sc->sc_total; 3301946f70aSBenjamin Marzinski m_sc->sc_free += l_sc->sc_free; 3311946f70aSBenjamin Marzinski m_sc->sc_dinodes += l_sc->sc_dinodes; 3321946f70aSBenjamin Marzinski memset(l_sc, 0, sizeof(struct gfs2_statfs_change)); 3331946f70aSBenjamin Marzinski memset(l_bh->b_data + sizeof(struct gfs2_dinode), 3341946f70aSBenjamin Marzinski 0, sizeof(struct gfs2_statfs_change)); 3351946f70aSBenjamin Marzinski gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode)); 336901c6c66SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 3371946f70aSBenjamin Marzinski } 3381946f70aSBenjamin Marzinski 3398c42d637SSteven Whitehouse int gfs2_statfs_sync(struct super_block *sb, int type) 340b3b94faaSDavid Teigland { 3418c42d637SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 342feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 343feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 344bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 345bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 346b3b94faaSDavid Teigland struct gfs2_holder gh; 347b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 348b3b94faaSDavid Teigland int error; 349b3b94faaSDavid Teigland 3502e60d768SBenjamin Marzinski sb_start_write(sb); 351b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 352b3b94faaSDavid Teigland &gh); 353b3b94faaSDavid Teigland if (error) 3542e60d768SBenjamin Marzinski goto out; 355b3b94faaSDavid Teigland 356b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 357b3b94faaSDavid Teigland if (error) 3582e60d768SBenjamin Marzinski goto out_unlock; 359b3b94faaSDavid Teigland 360b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 361b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 362b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 363b3b94faaSDavid Teigland if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) { 364b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 365b3b94faaSDavid Teigland goto out_bh; 366b3b94faaSDavid Teigland } 367b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 368b3b94faaSDavid Teigland 369b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 370b3b94faaSDavid Teigland if (error) 371b3b94faaSDavid Teigland goto out_bh; 372b3b94faaSDavid Teigland 373b3b94faaSDavid Teigland error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 374b3b94faaSDavid Teigland if (error) 375b3b94faaSDavid Teigland goto out_bh2; 376b3b94faaSDavid Teigland 3771946f70aSBenjamin Marzinski update_statfs(sdp, m_bh, l_bh); 3783d3c10f2SBenjamin Marzinski sdp->sd_statfs_force_sync = 0; 379b3b94faaSDavid Teigland 380b3b94faaSDavid Teigland gfs2_trans_end(sdp); 381b3b94faaSDavid Teigland 382b3b94faaSDavid Teigland out_bh2: 383b3b94faaSDavid Teigland brelse(l_bh); 384b3b94faaSDavid Teigland out_bh: 385b3b94faaSDavid Teigland brelse(m_bh); 3862e60d768SBenjamin Marzinski out_unlock: 387b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 3882e60d768SBenjamin Marzinski out: 3892e60d768SBenjamin Marzinski sb_end_write(sb); 390b3b94faaSDavid Teigland return error; 391b3b94faaSDavid Teigland } 392b3b94faaSDavid Teigland 393b3b94faaSDavid Teigland struct lfcc { 394b3b94faaSDavid Teigland struct list_head list; 395b3b94faaSDavid Teigland struct gfs2_holder gh; 396b3b94faaSDavid Teigland }; 397b3b94faaSDavid Teigland 398b3b94faaSDavid Teigland /** 399b3b94faaSDavid Teigland * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all 400b3b94faaSDavid Teigland * journals are clean 401b3b94faaSDavid Teigland * @sdp: the file system 402b3b94faaSDavid Teigland * @state: the state to put the transaction lock into 403b3b94faaSDavid Teigland * @t_gh: the hold on the transaction lock 404b3b94faaSDavid Teigland * 405b3b94faaSDavid Teigland * Returns: errno 406b3b94faaSDavid Teigland */ 407b3b94faaSDavid Teigland 40852b1cdcbSBob Peterson static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp) 409b3b94faaSDavid Teigland { 4105c676f6dSSteven Whitehouse struct gfs2_inode *ip; 411b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 412b3b94faaSDavid Teigland struct lfcc *lfcc; 413b3b94faaSDavid Teigland LIST_HEAD(list); 41455167622SAl Viro struct gfs2_log_header_host lh; 415b3b94faaSDavid Teigland int error; 416b3b94faaSDavid Teigland 417b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 418b3b94faaSDavid Teigland lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL); 419b3b94faaSDavid Teigland if (!lfcc) { 420b3b94faaSDavid Teigland error = -ENOMEM; 421b3b94faaSDavid Teigland goto out; 422b3b94faaSDavid Teigland } 423feaa7bbaSSteven Whitehouse ip = GFS2_I(jd->jd_inode); 424feaa7bbaSSteven Whitehouse error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh); 425b3b94faaSDavid Teigland if (error) { 426b3b94faaSDavid Teigland kfree(lfcc); 427b3b94faaSDavid Teigland goto out; 428b3b94faaSDavid Teigland } 429b3b94faaSDavid Teigland list_add(&lfcc->list, &list); 430b3b94faaSDavid Teigland } 431b3b94faaSDavid Teigland 43224972557SBenjamin Marzinski error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_EXCLUSIVE, 43352b1cdcbSBob Peterson GL_NOCACHE, &sdp->sd_freeze_gh); 43452b1cdcbSBob Peterson if (error) 43552b1cdcbSBob Peterson goto out; 436b3b94faaSDavid Teigland 437b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 438b3b94faaSDavid Teigland error = gfs2_jdesc_check(jd); 439b3b94faaSDavid Teigland if (error) 440b3b94faaSDavid Teigland break; 441f4686c26SAbhi Das error = gfs2_find_jhead(jd, &lh, false); 442b3b94faaSDavid Teigland if (error) 443b3b94faaSDavid Teigland break; 444b3b94faaSDavid Teigland if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 445b3b94faaSDavid Teigland error = -EBUSY; 446b3b94faaSDavid Teigland break; 447b3b94faaSDavid Teigland } 448b3b94faaSDavid Teigland } 449b3b94faaSDavid Teigland 450b3b94faaSDavid Teigland if (error) 45152b1cdcbSBob Peterson gfs2_glock_dq_uninit(&sdp->sd_freeze_gh); 452b3b94faaSDavid Teigland 453b3b94faaSDavid Teigland out: 454b3b94faaSDavid Teigland while (!list_empty(&list)) { 455969183bcSAndreas Gruenbacher lfcc = list_first_entry(&list, struct lfcc, list); 456b3b94faaSDavid Teigland list_del(&lfcc->list); 457b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&lfcc->gh); 458b3b94faaSDavid Teigland kfree(lfcc); 459b3b94faaSDavid Teigland } 460b3b94faaSDavid Teigland return error; 461b3b94faaSDavid Teigland } 462b3b94faaSDavid Teigland 4639eed04cdSSteven Whitehouse void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 4649eed04cdSSteven Whitehouse { 4659eed04cdSSteven Whitehouse struct gfs2_dinode *str = buf; 4669eed04cdSSteven Whitehouse 4679eed04cdSSteven Whitehouse str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 4689eed04cdSSteven Whitehouse str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 4699eed04cdSSteven Whitehouse str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 4709eed04cdSSteven Whitehouse str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 4719eed04cdSSteven Whitehouse str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 4729eed04cdSSteven Whitehouse str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 473d0546426SEric W. Biederman str->di_uid = cpu_to_be32(i_uid_read(&ip->i_inode)); 474d0546426SEric W. Biederman str->di_gid = cpu_to_be32(i_gid_read(&ip->i_inode)); 4759eed04cdSSteven Whitehouse str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 4769eed04cdSSteven Whitehouse str->di_size = cpu_to_be64(i_size_read(&ip->i_inode)); 4779eed04cdSSteven Whitehouse str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode)); 4789eed04cdSSteven Whitehouse str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 4799eed04cdSSteven Whitehouse str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec); 4809eed04cdSSteven Whitehouse str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec); 4819eed04cdSSteven Whitehouse 4829eed04cdSSteven Whitehouse str->di_goal_meta = cpu_to_be64(ip->i_goal); 4839eed04cdSSteven Whitehouse str->di_goal_data = cpu_to_be64(ip->i_goal); 4849eed04cdSSteven Whitehouse str->di_generation = cpu_to_be64(ip->i_generation); 4859eed04cdSSteven Whitehouse 4869eed04cdSSteven Whitehouse str->di_flags = cpu_to_be32(ip->i_diskflags); 4879eed04cdSSteven Whitehouse str->di_height = cpu_to_be16(ip->i_height); 4889eed04cdSSteven Whitehouse str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && 4899eed04cdSSteven Whitehouse !(ip->i_diskflags & GFS2_DIF_EXHASH) ? 4909eed04cdSSteven Whitehouse GFS2_FORMAT_DE : 0); 4919eed04cdSSteven Whitehouse str->di_depth = cpu_to_be16(ip->i_depth); 4929eed04cdSSteven Whitehouse str->di_entries = cpu_to_be32(ip->i_entries); 4939eed04cdSSteven Whitehouse 4949eed04cdSSteven Whitehouse str->di_eattr = cpu_to_be64(ip->i_eattr); 4959eed04cdSSteven Whitehouse str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 4969eed04cdSSteven Whitehouse str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); 4979eed04cdSSteven Whitehouse str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); 4989eed04cdSSteven Whitehouse } 4999e6e0a12SSteven Whitehouse 5009e6e0a12SSteven Whitehouse /** 5019e6e0a12SSteven Whitehouse * gfs2_write_inode - Make sure the inode is stable on the disk 5029e6e0a12SSteven Whitehouse * @inode: The inode 5031027efaaSSteven Whitehouse * @wbc: The writeback control structure 5049e6e0a12SSteven Whitehouse * 5059e6e0a12SSteven Whitehouse * Returns: errno 5069e6e0a12SSteven Whitehouse */ 5079e6e0a12SSteven Whitehouse 508a9185b41SChristoph Hellwig static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc) 5099e6e0a12SSteven Whitehouse { 5109e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 5119e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 5121027efaaSSteven Whitehouse struct address_space *metamapping = gfs2_glock2aspace(ip->i_gl); 513de1414a6SChristoph Hellwig struct backing_dev_info *bdi = inode_to_bdi(metamapping->host); 514ab9bbda0SSteven Whitehouse int ret = 0; 515adbc3ddfSBob Peterson bool flush_all = (wbc->sync_mode == WB_SYNC_ALL || gfs2_is_jdata(ip)); 5169e6e0a12SSteven Whitehouse 517adbc3ddfSBob Peterson if (flush_all) 518c1696fb8SBob Peterson gfs2_log_flush(GFS2_SB(inode), ip->i_gl, 519805c0907SBob Peterson GFS2_LOG_HEAD_FLUSH_NORMAL | 520805c0907SBob Peterson GFS2_LFC_WRITE_INODE); 521a88a341aSTejun Heo if (bdi->wb.dirty_exceeded) 5224667a0ecSSteven Whitehouse gfs2_ail1_flush(sdp, wbc); 5231d4ec642SSteven Whitehouse else 5241d4ec642SSteven Whitehouse filemap_fdatawrite(metamapping); 525adbc3ddfSBob Peterson if (flush_all) 5261027efaaSSteven Whitehouse ret = filemap_fdatawait(metamapping); 5271027efaaSSteven Whitehouse if (ret) 5281027efaaSSteven Whitehouse mark_inode_dirty_sync(inode); 529957a7acdSAbhi Das else { 530957a7acdSAbhi Das spin_lock(&inode->i_lock); 531957a7acdSAbhi Das if (!(inode->i_flags & I_DIRTY)) 532957a7acdSAbhi Das gfs2_ordered_del_inode(ip); 533957a7acdSAbhi Das spin_unlock(&inode->i_lock); 534957a7acdSAbhi Das } 5359e6e0a12SSteven Whitehouse return ret; 5369e6e0a12SSteven Whitehouse } 5379e6e0a12SSteven Whitehouse 5389e6e0a12SSteven Whitehouse /** 539ab9bbda0SSteven Whitehouse * gfs2_dirty_inode - check for atime updates 540ab9bbda0SSteven Whitehouse * @inode: The inode in question 541ab9bbda0SSteven Whitehouse * @flags: The type of dirty 542ab9bbda0SSteven Whitehouse * 543ab9bbda0SSteven Whitehouse * Unfortunately it can be called under any combination of inode 544ab9bbda0SSteven Whitehouse * glock and transaction lock, so we have to check carefully. 545ab9bbda0SSteven Whitehouse * 546ab9bbda0SSteven Whitehouse * At the moment this deals only with atime - it should be possible 547ab9bbda0SSteven Whitehouse * to expand that role in future, once a review of the locking has 548ab9bbda0SSteven Whitehouse * been carried out. 549ab9bbda0SSteven Whitehouse */ 550ab9bbda0SSteven Whitehouse 551ab9bbda0SSteven Whitehouse static void gfs2_dirty_inode(struct inode *inode, int flags) 552ab9bbda0SSteven Whitehouse { 553ab9bbda0SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 554ab9bbda0SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 555ab9bbda0SSteven Whitehouse struct buffer_head *bh; 556ab9bbda0SSteven Whitehouse struct gfs2_holder gh; 557ab9bbda0SSteven Whitehouse int need_unlock = 0; 558ab9bbda0SSteven Whitehouse int need_endtrans = 0; 559ab9bbda0SSteven Whitehouse int ret; 560ab9bbda0SSteven Whitehouse 5610e11f644SChristoph Hellwig if (!(flags & I_DIRTY_INODE)) 562ab9bbda0SSteven Whitehouse return; 563eb43e660SBob Peterson if (unlikely(gfs2_withdrawn(sdp))) 5640d1c7ae9SBob Peterson return; 565ab9bbda0SSteven Whitehouse if (!gfs2_glock_is_locked_by_me(ip->i_gl)) { 566ab9bbda0SSteven Whitehouse ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 567ab9bbda0SSteven Whitehouse if (ret) { 568ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: glock %d\n", ret); 569ab9bbda0SSteven Whitehouse return; 570ab9bbda0SSteven Whitehouse } 571ab9bbda0SSteven Whitehouse need_unlock = 1; 5723d162688SBenjamin Marzinski } else if (WARN_ON_ONCE(ip->i_gl->gl_state != LM_ST_EXCLUSIVE)) 5733d162688SBenjamin Marzinski return; 574ab9bbda0SSteven Whitehouse 575ab9bbda0SSteven Whitehouse if (current->journal_info == NULL) { 576ab9bbda0SSteven Whitehouse ret = gfs2_trans_begin(sdp, RES_DINODE, 0); 577ab9bbda0SSteven Whitehouse if (ret) { 578ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: gfs2_trans_begin %d\n", ret); 579ab9bbda0SSteven Whitehouse goto out; 580ab9bbda0SSteven Whitehouse } 581ab9bbda0SSteven Whitehouse need_endtrans = 1; 582ab9bbda0SSteven Whitehouse } 583ab9bbda0SSteven Whitehouse 584ab9bbda0SSteven Whitehouse ret = gfs2_meta_inode_buffer(ip, &bh); 585ab9bbda0SSteven Whitehouse if (ret == 0) { 586350a9b0aSSteven Whitehouse gfs2_trans_add_meta(ip->i_gl, bh); 587ab9bbda0SSteven Whitehouse gfs2_dinode_out(ip, bh->b_data); 588ab9bbda0SSteven Whitehouse brelse(bh); 589ab9bbda0SSteven Whitehouse } 590ab9bbda0SSteven Whitehouse 591ab9bbda0SSteven Whitehouse if (need_endtrans) 592ab9bbda0SSteven Whitehouse gfs2_trans_end(sdp); 593ab9bbda0SSteven Whitehouse out: 594ab9bbda0SSteven Whitehouse if (need_unlock) 595ab9bbda0SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 596ab9bbda0SSteven Whitehouse } 597ab9bbda0SSteven Whitehouse 598ab9bbda0SSteven Whitehouse /** 5999e6e0a12SSteven Whitehouse * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one 6009e6e0a12SSteven Whitehouse * @sdp: the filesystem 6019e6e0a12SSteven Whitehouse * 6029e6e0a12SSteven Whitehouse * Returns: errno 6039e6e0a12SSteven Whitehouse */ 6049e6e0a12SSteven Whitehouse 6051f52aa08SAndrew Price int gfs2_make_fs_ro(struct gfs2_sbd *sdp) 6069e6e0a12SSteven Whitehouse { 6072e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 608601ef0d5SBob Peterson int error = 0; 609601ef0d5SBob Peterson int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 6109e6e0a12SSteven Whitehouse 611601ef0d5SBob Peterson gfs2_holder_mark_uninitialized(&freeze_gh); 612601ef0d5SBob Peterson if (sdp->sd_freeze_gl && 613601ef0d5SBob Peterson !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) { 614601ef0d5SBob Peterson if (!log_write_allowed) { 615601ef0d5SBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, 616601ef0d5SBob Peterson LM_ST_SHARED, GL_NOCACHE | 617601ef0d5SBob Peterson LM_FLAG_TRY, &freeze_gh); 618601ef0d5SBob Peterson if (error == GLR_TRYFAILED) 619601ef0d5SBob Peterson error = 0; 620601ef0d5SBob Peterson } else { 621601ef0d5SBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, 622601ef0d5SBob Peterson LM_ST_SHARED, GL_NOCACHE, 6232e60d768SBenjamin Marzinski &freeze_gh); 624eb43e660SBob Peterson if (error && !gfs2_withdrawn(sdp)) 62524972557SBenjamin Marzinski return error; 626601ef0d5SBob Peterson } 627601ef0d5SBob Peterson } 62824972557SBenjamin Marzinski 629a0e3cc65SAndreas Gruenbacher gfs2_flush_delete_work(sdp); 630601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_quotad_process) 631601ef0d5SBob Peterson fs_warn(sdp, "The quotad daemon is withdrawing.\n"); 632601ef0d5SBob Peterson else if (sdp->sd_quotad_process) 6338ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 6345b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 635601ef0d5SBob Peterson 636601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_logd_process) 637601ef0d5SBob Peterson fs_warn(sdp, "The logd daemon is withdrawing.\n"); 638601ef0d5SBob Peterson else if (sdp->sd_logd_process) 6398ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 6405b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 6418ad151c2SSteven Whitehouse 642601ef0d5SBob Peterson if (log_write_allowed) { 643ceed1723SJan Kara gfs2_quota_sync(sdp->sd_vfs, 0); 6448c42d637SSteven Whitehouse gfs2_statfs_sync(sdp->sd_vfs, 0); 6459e6e0a12SSteven Whitehouse 646805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 647805c0907SBob Peterson GFS2_LFC_MAKE_FS_RO); 648601ef0d5SBob Peterson wait_event(sdp->sd_reserving_log_wait, 649601ef0d5SBob Peterson atomic_read(&sdp->sd_reserving_log) == 0); 650601ef0d5SBob Peterson gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == 651601ef0d5SBob Peterson sdp->sd_jdesc->jd_blocks); 652601ef0d5SBob Peterson } else { 653601ef0d5SBob Peterson wait_event_timeout(sdp->sd_reserving_log_wait, 654601ef0d5SBob Peterson atomic_read(&sdp->sd_reserving_log) == 0, 655601ef0d5SBob Peterson HZ * 5); 656601ef0d5SBob Peterson } 6576df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&freeze_gh)) 6582e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 6599e6e0a12SSteven Whitehouse 6609e6e0a12SSteven Whitehouse gfs2_quota_cleanup(sdp); 6619e6e0a12SSteven Whitehouse 662601ef0d5SBob Peterson if (!log_write_allowed) 663601ef0d5SBob Peterson sdp->sd_vfs->s_flags |= SB_RDONLY; 664601ef0d5SBob Peterson 6659e6e0a12SSteven Whitehouse return error; 6669e6e0a12SSteven Whitehouse } 6679e6e0a12SSteven Whitehouse 6689e6e0a12SSteven Whitehouse /** 6699e6e0a12SSteven Whitehouse * gfs2_put_super - Unmount the filesystem 6709e6e0a12SSteven Whitehouse * @sb: The VFS superblock 6719e6e0a12SSteven Whitehouse * 6729e6e0a12SSteven Whitehouse */ 6739e6e0a12SSteven Whitehouse 6749e6e0a12SSteven Whitehouse static void gfs2_put_super(struct super_block *sb) 6759e6e0a12SSteven Whitehouse { 6769e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 6779e6e0a12SSteven Whitehouse int error; 6789e6e0a12SSteven Whitehouse struct gfs2_jdesc *jd; 6799e6e0a12SSteven Whitehouse 6809e6e0a12SSteven Whitehouse /* No more recovery requests */ 6819e6e0a12SSteven Whitehouse set_bit(SDF_NORECOVERY, &sdp->sd_flags); 6829e6e0a12SSteven Whitehouse smp_mb(); 6839e6e0a12SSteven Whitehouse 6849e6e0a12SSteven Whitehouse /* Wait on outstanding recovery */ 6859e6e0a12SSteven Whitehouse restart: 6869e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_jindex_spin); 6879e6e0a12SSteven Whitehouse list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 6889e6e0a12SSteven Whitehouse if (!test_bit(JDF_RECOVERY, &jd->jd_flags)) 6899e6e0a12SSteven Whitehouse continue; 6909e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 6919e6e0a12SSteven Whitehouse wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 69274316201SNeilBrown TASK_UNINTERRUPTIBLE); 6939e6e0a12SSteven Whitehouse goto restart; 6949e6e0a12SSteven Whitehouse } 6959e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 6969e6e0a12SSteven Whitehouse 697bc98a42cSDavid Howells if (!sb_rdonly(sb)) { 6989e6e0a12SSteven Whitehouse error = gfs2_make_fs_ro(sdp); 6999e6e0a12SSteven Whitehouse if (error) 7009e6e0a12SSteven Whitehouse gfs2_io_error(sdp); 7019e6e0a12SSteven Whitehouse } 7029e6e0a12SSteven Whitehouse /* At this point, we're through modifying the disk */ 7039e6e0a12SSteven Whitehouse 7049e6e0a12SSteven Whitehouse /* Release stuff */ 7059e6e0a12SSteven Whitehouse 7069e6e0a12SSteven Whitehouse iput(sdp->sd_jindex); 7079e6e0a12SSteven Whitehouse iput(sdp->sd_statfs_inode); 7089e6e0a12SSteven Whitehouse iput(sdp->sd_rindex); 7099e6e0a12SSteven Whitehouse iput(sdp->sd_quota_inode); 7109e6e0a12SSteven Whitehouse 7119e6e0a12SSteven Whitehouse gfs2_glock_put(sdp->sd_rename_gl); 71224972557SBenjamin Marzinski gfs2_glock_put(sdp->sd_freeze_gl); 7139e6e0a12SSteven Whitehouse 7149e6e0a12SSteven Whitehouse if (!sdp->sd_args.ar_spectator) { 715601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_journal_gh)) 7169e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_journal_gh); 717601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_jinode_gh)) 7189e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_jinode_gh); 7199e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_sc_gh); 7209e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_qc_gh); 7219e6e0a12SSteven Whitehouse iput(sdp->sd_sc_inode); 7229e6e0a12SSteven Whitehouse iput(sdp->sd_qc_inode); 7239e6e0a12SSteven Whitehouse } 7249e6e0a12SSteven Whitehouse 7259e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_live_gh); 7269e6e0a12SSteven Whitehouse gfs2_clear_rgrpd(sdp); 7279e6e0a12SSteven Whitehouse gfs2_jindex_free(sdp); 7289e6e0a12SSteven Whitehouse /* Take apart glock structures and buffer lists */ 7299e6e0a12SSteven Whitehouse gfs2_gl_hash_clear(sdp); 730b2fb7dabSBob Peterson gfs2_delete_debugfs_file(sdp); 7319e6e0a12SSteven Whitehouse /* Unmount the locking protocol */ 7329e6e0a12SSteven Whitehouse gfs2_lm_unmount(sdp); 7339e6e0a12SSteven Whitehouse 7349e6e0a12SSteven Whitehouse /* At this point, we're through participating in the lockspace */ 7359e6e0a12SSteven Whitehouse gfs2_sys_fs_del(sdp); 7369e6e0a12SSteven Whitehouse } 7379e6e0a12SSteven Whitehouse 7389e6e0a12SSteven Whitehouse /** 7399e6e0a12SSteven Whitehouse * gfs2_sync_fs - sync the filesystem 7409e6e0a12SSteven Whitehouse * @sb: the superblock 7419e6e0a12SSteven Whitehouse * 7429e6e0a12SSteven Whitehouse * Flushes the log to disk. 7439e6e0a12SSteven Whitehouse */ 7449e6e0a12SSteven Whitehouse 7459e6e0a12SSteven Whitehouse static int gfs2_sync_fs(struct super_block *sb, int wait) 7469e6e0a12SSteven Whitehouse { 7471027efaaSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 748a1177825SJan Kara 749a1177825SJan Kara gfs2_quota_sync(sb, -1); 750942b0cddSBob Peterson if (wait) 751805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 752805c0907SBob Peterson GFS2_LFC_SYNC_FS); 753942b0cddSBob Peterson return sdp->sd_log_error; 7549e6e0a12SSteven Whitehouse } 7559e6e0a12SSteven Whitehouse 7562e60d768SBenjamin Marzinski void gfs2_freeze_func(struct work_struct *work) 7572e60d768SBenjamin Marzinski { 7582e60d768SBenjamin Marzinski int error; 7592e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 7602e60d768SBenjamin Marzinski struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_freeze_work); 7612e60d768SBenjamin Marzinski struct super_block *sb = sdp->sd_vfs; 7622e60d768SBenjamin Marzinski 7632e60d768SBenjamin Marzinski atomic_inc(&sb->s_active); 7642e60d768SBenjamin Marzinski error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 0, 7652e60d768SBenjamin Marzinski &freeze_gh); 7662e60d768SBenjamin Marzinski if (error) { 767f29e62eeSBob Peterson fs_info(sdp, "GFS2: couldn't get freeze lock : %d\n", error); 7682e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7698f918219SAbhi Das } else { 7702e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN); 7712e60d768SBenjamin Marzinski error = thaw_super(sb); 7722e60d768SBenjamin Marzinski if (error) { 773f29e62eeSBob Peterson fs_info(sdp, "GFS2: couldn't thaw filesystem: %d\n", 7742e60d768SBenjamin Marzinski error); 7752e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7762e60d768SBenjamin Marzinski } 7772e60d768SBenjamin Marzinski if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 7782e60d768SBenjamin Marzinski freeze_gh.gh_flags |= GL_NOCACHE; 7792e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 7802e60d768SBenjamin Marzinski } 7812e60d768SBenjamin Marzinski deactivate_super(sb); 7828f918219SAbhi Das clear_bit_unlock(SDF_FS_FROZEN, &sdp->sd_flags); 7838f918219SAbhi Das wake_up_bit(&sdp->sd_flags, SDF_FS_FROZEN); 7842e60d768SBenjamin Marzinski return; 7852e60d768SBenjamin Marzinski } 7862e60d768SBenjamin Marzinski 7879e6e0a12SSteven Whitehouse /** 7889e6e0a12SSteven Whitehouse * gfs2_freeze - prevent further writes to the filesystem 7899e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 7909e6e0a12SSteven Whitehouse * 7919e6e0a12SSteven Whitehouse */ 7929e6e0a12SSteven Whitehouse 7939e6e0a12SSteven Whitehouse static int gfs2_freeze(struct super_block *sb) 7949e6e0a12SSteven Whitehouse { 7959e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 7962e60d768SBenjamin Marzinski int error = 0; 7979e6e0a12SSteven Whitehouse 7982e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 7992e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_UNFROZEN) 8002e60d768SBenjamin Marzinski goto out; 8012e60d768SBenjamin Marzinski 80260528afaSBob Peterson for (;;) { 803eb43e660SBob Peterson if (gfs2_withdrawn(sdp)) { 8042e60d768SBenjamin Marzinski error = -EINVAL; 8052e60d768SBenjamin Marzinski goto out; 8062e60d768SBenjamin Marzinski } 8079e6e0a12SSteven Whitehouse 80852b1cdcbSBob Peterson error = gfs2_lock_fs_check_clean(sdp); 8099e6e0a12SSteven Whitehouse if (!error) 8109e6e0a12SSteven Whitehouse break; 8119e6e0a12SSteven Whitehouse 81255317f5bSBob Peterson if (error == -EBUSY) 8139e6e0a12SSteven Whitehouse fs_err(sdp, "waiting for recovery before freeze\n"); 81452b1cdcbSBob Peterson else if (error == -EIO) { 81552b1cdcbSBob Peterson fs_err(sdp, "Fatal IO error: cannot freeze gfs2 due " 81652b1cdcbSBob Peterson "to recovery error.\n"); 81752b1cdcbSBob Peterson goto out; 81852b1cdcbSBob Peterson } else { 8199e6e0a12SSteven Whitehouse fs_err(sdp, "error freezing FS: %d\n", error); 82052b1cdcbSBob Peterson } 8219e6e0a12SSteven Whitehouse fs_err(sdp, "retrying...\n"); 8229e6e0a12SSteven Whitehouse msleep(1000); 8239e6e0a12SSteven Whitehouse } 8248f918219SAbhi Das set_bit(SDF_FS_FROZEN, &sdp->sd_flags); 8252e60d768SBenjamin Marzinski out: 8262e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8272e60d768SBenjamin Marzinski return error; 8289e6e0a12SSteven Whitehouse } 8299e6e0a12SSteven Whitehouse 8309e6e0a12SSteven Whitehouse /** 8319e6e0a12SSteven Whitehouse * gfs2_unfreeze - reallow writes to the filesystem 8329e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 8339e6e0a12SSteven Whitehouse * 8349e6e0a12SSteven Whitehouse */ 8359e6e0a12SSteven Whitehouse 8369e6e0a12SSteven Whitehouse static int gfs2_unfreeze(struct super_block *sb) 8379e6e0a12SSteven Whitehouse { 838d564053fSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 839d564053fSSteven Whitehouse 8402e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 8412e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_FROZEN || 8426df9f9a2SAndreas Gruenbacher !gfs2_holder_initialized(&sdp->sd_freeze_gh)) { 8432e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8442e60d768SBenjamin Marzinski return 0; 8452e60d768SBenjamin Marzinski } 8462e60d768SBenjamin Marzinski 847d564053fSSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_freeze_gh); 8482e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8498f918219SAbhi Das return wait_on_bit(&sdp->sd_flags, SDF_FS_FROZEN, TASK_INTERRUPTIBLE); 8509e6e0a12SSteven Whitehouse } 8519e6e0a12SSteven Whitehouse 8529e6e0a12SSteven Whitehouse /** 8539e6e0a12SSteven Whitehouse * statfs_fill - fill in the sg for a given RG 8549e6e0a12SSteven Whitehouse * @rgd: the RG 8559e6e0a12SSteven Whitehouse * @sc: the sc structure 8569e6e0a12SSteven Whitehouse * 8579e6e0a12SSteven Whitehouse * Returns: 0 on success, -ESTALE if the LVB is invalid 8589e6e0a12SSteven Whitehouse */ 8599e6e0a12SSteven Whitehouse 8609e6e0a12SSteven Whitehouse static int statfs_slow_fill(struct gfs2_rgrpd *rgd, 8619e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *sc) 8629e6e0a12SSteven Whitehouse { 8639e6e0a12SSteven Whitehouse gfs2_rgrp_verify(rgd); 8649e6e0a12SSteven Whitehouse sc->sc_total += rgd->rd_data; 8659e6e0a12SSteven Whitehouse sc->sc_free += rgd->rd_free; 8669e6e0a12SSteven Whitehouse sc->sc_dinodes += rgd->rd_dinodes; 8679e6e0a12SSteven Whitehouse return 0; 8689e6e0a12SSteven Whitehouse } 8699e6e0a12SSteven Whitehouse 8709e6e0a12SSteven Whitehouse /** 8719e6e0a12SSteven Whitehouse * gfs2_statfs_slow - Stat a filesystem using asynchronous locking 8729e6e0a12SSteven Whitehouse * @sdp: the filesystem 8739e6e0a12SSteven Whitehouse * @sc: the sc info that will be returned 8749e6e0a12SSteven Whitehouse * 8759e6e0a12SSteven Whitehouse * Any error (other than a signal) will cause this routine to fall back 8769e6e0a12SSteven Whitehouse * to the synchronous version. 8779e6e0a12SSteven Whitehouse * 8789e6e0a12SSteven Whitehouse * FIXME: This really shouldn't busy wait like this. 8799e6e0a12SSteven Whitehouse * 8809e6e0a12SSteven Whitehouse * Returns: errno 8819e6e0a12SSteven Whitehouse */ 8829e6e0a12SSteven Whitehouse 8839e6e0a12SSteven Whitehouse static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 8849e6e0a12SSteven Whitehouse { 8859e6e0a12SSteven Whitehouse struct gfs2_rgrpd *rgd_next; 8869e6e0a12SSteven Whitehouse struct gfs2_holder *gha, *gh; 8879e6e0a12SSteven Whitehouse unsigned int slots = 64; 8889e6e0a12SSteven Whitehouse unsigned int x; 8899e6e0a12SSteven Whitehouse int done; 8909e6e0a12SSteven Whitehouse int error = 0, err; 8919e6e0a12SSteven Whitehouse 8929e6e0a12SSteven Whitehouse memset(sc, 0, sizeof(struct gfs2_statfs_change_host)); 8936da2ec56SKees Cook gha = kmalloc_array(slots, sizeof(struct gfs2_holder), GFP_KERNEL); 8949e6e0a12SSteven Whitehouse if (!gha) 8959e6e0a12SSteven Whitehouse return -ENOMEM; 8966df9f9a2SAndreas Gruenbacher for (x = 0; x < slots; x++) 8976df9f9a2SAndreas Gruenbacher gfs2_holder_mark_uninitialized(gha + x); 8989e6e0a12SSteven Whitehouse 8999e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_first(sdp); 9009e6e0a12SSteven Whitehouse 9019e6e0a12SSteven Whitehouse for (;;) { 9029e6e0a12SSteven Whitehouse done = 1; 9039e6e0a12SSteven Whitehouse 9049e6e0a12SSteven Whitehouse for (x = 0; x < slots; x++) { 9059e6e0a12SSteven Whitehouse gh = gha + x; 9069e6e0a12SSteven Whitehouse 9076df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh) && gfs2_glock_poll(gh)) { 9089e6e0a12SSteven Whitehouse err = gfs2_glock_wait(gh); 9099e6e0a12SSteven Whitehouse if (err) { 9109e6e0a12SSteven Whitehouse gfs2_holder_uninit(gh); 9119e6e0a12SSteven Whitehouse error = err; 9129e6e0a12SSteven Whitehouse } else { 9136f6597baSAndreas Gruenbacher if (!error) { 9146f6597baSAndreas Gruenbacher struct gfs2_rgrpd *rgd = 9156f6597baSAndreas Gruenbacher gfs2_glock2rgrp(gh->gh_gl); 9166f6597baSAndreas Gruenbacher 9176f6597baSAndreas Gruenbacher error = statfs_slow_fill(rgd, sc); 9186f6597baSAndreas Gruenbacher } 9199e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(gh); 9209e6e0a12SSteven Whitehouse } 9219e6e0a12SSteven Whitehouse } 9229e6e0a12SSteven Whitehouse 9236df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh)) 9249e6e0a12SSteven Whitehouse done = 0; 9259e6e0a12SSteven Whitehouse else if (rgd_next && !error) { 9269e6e0a12SSteven Whitehouse error = gfs2_glock_nq_init(rgd_next->rd_gl, 9279e6e0a12SSteven Whitehouse LM_ST_SHARED, 9289e6e0a12SSteven Whitehouse GL_ASYNC, 9299e6e0a12SSteven Whitehouse gh); 9309e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_next(rgd_next); 9319e6e0a12SSteven Whitehouse done = 0; 9329e6e0a12SSteven Whitehouse } 9339e6e0a12SSteven Whitehouse 9349e6e0a12SSteven Whitehouse if (signal_pending(current)) 9359e6e0a12SSteven Whitehouse error = -ERESTARTSYS; 9369e6e0a12SSteven Whitehouse } 9379e6e0a12SSteven Whitehouse 9389e6e0a12SSteven Whitehouse if (done) 9399e6e0a12SSteven Whitehouse break; 9409e6e0a12SSteven Whitehouse 9419e6e0a12SSteven Whitehouse yield(); 9429e6e0a12SSteven Whitehouse } 9439e6e0a12SSteven Whitehouse 9449e6e0a12SSteven Whitehouse kfree(gha); 9459e6e0a12SSteven Whitehouse return error; 9469e6e0a12SSteven Whitehouse } 9479e6e0a12SSteven Whitehouse 9489e6e0a12SSteven Whitehouse /** 9499e6e0a12SSteven Whitehouse * gfs2_statfs_i - Do a statfs 9509e6e0a12SSteven Whitehouse * @sdp: the filesystem 9519e6e0a12SSteven Whitehouse * @sg: the sg structure 9529e6e0a12SSteven Whitehouse * 9539e6e0a12SSteven Whitehouse * Returns: errno 9549e6e0a12SSteven Whitehouse */ 9559e6e0a12SSteven Whitehouse 9569e6e0a12SSteven Whitehouse static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 9579e6e0a12SSteven Whitehouse { 9589e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 9599e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 9609e6e0a12SSteven Whitehouse 9619e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_statfs_spin); 9629e6e0a12SSteven Whitehouse 9639e6e0a12SSteven Whitehouse *sc = *m_sc; 9649e6e0a12SSteven Whitehouse sc->sc_total += l_sc->sc_total; 9659e6e0a12SSteven Whitehouse sc->sc_free += l_sc->sc_free; 9669e6e0a12SSteven Whitehouse sc->sc_dinodes += l_sc->sc_dinodes; 9679e6e0a12SSteven Whitehouse 9689e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_statfs_spin); 9699e6e0a12SSteven Whitehouse 9709e6e0a12SSteven Whitehouse if (sc->sc_free < 0) 9719e6e0a12SSteven Whitehouse sc->sc_free = 0; 9729e6e0a12SSteven Whitehouse if (sc->sc_free > sc->sc_total) 9739e6e0a12SSteven Whitehouse sc->sc_free = sc->sc_total; 9749e6e0a12SSteven Whitehouse if (sc->sc_dinodes < 0) 9759e6e0a12SSteven Whitehouse sc->sc_dinodes = 0; 9769e6e0a12SSteven Whitehouse 9779e6e0a12SSteven Whitehouse return 0; 9789e6e0a12SSteven Whitehouse } 9799e6e0a12SSteven Whitehouse 9809e6e0a12SSteven Whitehouse /** 9819e6e0a12SSteven Whitehouse * gfs2_statfs - Gather and return stats about the filesystem 9829e6e0a12SSteven Whitehouse * @sb: The superblock 9839e6e0a12SSteven Whitehouse * @statfsbuf: The buffer 9849e6e0a12SSteven Whitehouse * 9859e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 9869e6e0a12SSteven Whitehouse */ 9879e6e0a12SSteven Whitehouse 9889e6e0a12SSteven Whitehouse static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 9899e6e0a12SSteven Whitehouse { 990fc64005cSAl Viro struct super_block *sb = dentry->d_sb; 9919e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 9929e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host sc; 9939e6e0a12SSteven Whitehouse int error; 9949e6e0a12SSteven Whitehouse 9958339ee54SSteven Whitehouse error = gfs2_rindex_update(sdp); 9968339ee54SSteven Whitehouse if (error) 9978339ee54SSteven Whitehouse return error; 9988339ee54SSteven Whitehouse 9999e6e0a12SSteven Whitehouse if (gfs2_tune_get(sdp, gt_statfs_slow)) 10009e6e0a12SSteven Whitehouse error = gfs2_statfs_slow(sdp, &sc); 10019e6e0a12SSteven Whitehouse else 10029e6e0a12SSteven Whitehouse error = gfs2_statfs_i(sdp, &sc); 10039e6e0a12SSteven Whitehouse 10049e6e0a12SSteven Whitehouse if (error) 10059e6e0a12SSteven Whitehouse return error; 10069e6e0a12SSteven Whitehouse 10079e6e0a12SSteven Whitehouse buf->f_type = GFS2_MAGIC; 10089e6e0a12SSteven Whitehouse buf->f_bsize = sdp->sd_sb.sb_bsize; 10099e6e0a12SSteven Whitehouse buf->f_blocks = sc.sc_total; 10109e6e0a12SSteven Whitehouse buf->f_bfree = sc.sc_free; 10119e6e0a12SSteven Whitehouse buf->f_bavail = sc.sc_free; 10129e6e0a12SSteven Whitehouse buf->f_files = sc.sc_dinodes + sc.sc_free; 10139e6e0a12SSteven Whitehouse buf->f_ffree = sc.sc_free; 10149e6e0a12SSteven Whitehouse buf->f_namelen = GFS2_FNAMESIZE; 10159e6e0a12SSteven Whitehouse 10169e6e0a12SSteven Whitehouse return 0; 10179e6e0a12SSteven Whitehouse } 10189e6e0a12SSteven Whitehouse 10199e6e0a12SSteven Whitehouse /** 10209e6e0a12SSteven Whitehouse * gfs2_drop_inode - Drop an inode (test for remote unlink) 10219e6e0a12SSteven Whitehouse * @inode: The inode to drop 10229e6e0a12SSteven Whitehouse * 102361b91cfdSAndreas Gruenbacher * If we've received a callback on an iopen lock then it's because a 10249e6e0a12SSteven Whitehouse * remote node tried to deallocate the inode but failed due to this node 10259e6e0a12SSteven Whitehouse * still having the inode open. Here we mark the link count zero 10269e6e0a12SSteven Whitehouse * since we know that it must have reached zero if the GLF_DEMOTE flag 10279e6e0a12SSteven Whitehouse * is set on the iopen glock. If we didn't do a disk read since the 10289e6e0a12SSteven Whitehouse * remote node removed the final link then we might otherwise miss 10299e6e0a12SSteven Whitehouse * this event. This check ensures that this node will deallocate the 10309e6e0a12SSteven Whitehouse * inode's blocks, or alternatively pass the baton on to another 10319e6e0a12SSteven Whitehouse * node for later deallocation. 10329e6e0a12SSteven Whitehouse */ 10339e6e0a12SSteven Whitehouse 103445321ac5SAl Viro static int gfs2_drop_inode(struct inode *inode) 10359e6e0a12SSteven Whitehouse { 10369e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 10379e6e0a12SSteven Whitehouse 10386df9f9a2SAndreas Gruenbacher if (!test_bit(GIF_FREE_VFS_INODE, &ip->i_flags) && 10396df9f9a2SAndreas Gruenbacher inode->i_nlink && 10406df9f9a2SAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 10419e6e0a12SSteven Whitehouse struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 10426df9f9a2SAndreas Gruenbacher if (test_bit(GLF_DEMOTE, &gl->gl_flags)) 10439e6e0a12SSteven Whitehouse clear_nlink(inode); 10449e6e0a12SSteven Whitehouse } 10456a1c8f6dSAndreas Gruenbacher 10466a1c8f6dSAndreas Gruenbacher /* 10476a1c8f6dSAndreas Gruenbacher * When under memory pressure when an inode's link count has dropped to 10486a1c8f6dSAndreas Gruenbacher * zero, defer deleting the inode to the delete workqueue. This avoids 10496a1c8f6dSAndreas Gruenbacher * calling into DLM under memory pressure, which can deadlock. 10506a1c8f6dSAndreas Gruenbacher */ 10516a1c8f6dSAndreas Gruenbacher if (!inode->i_nlink && 10526a1c8f6dSAndreas Gruenbacher unlikely(current->flags & PF_MEMALLOC) && 10536a1c8f6dSAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 10546a1c8f6dSAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 10556a1c8f6dSAndreas Gruenbacher 10566a1c8f6dSAndreas Gruenbacher gfs2_glock_hold(gl); 1057a0e3cc65SAndreas Gruenbacher if (!gfs2_queue_delete_work(gl, 0)) 10586a1c8f6dSAndreas Gruenbacher gfs2_glock_queue_put(gl); 10596a1c8f6dSAndreas Gruenbacher return false; 10606a1c8f6dSAndreas Gruenbacher } 10616a1c8f6dSAndreas Gruenbacher 106245321ac5SAl Viro return generic_drop_inode(inode); 10639e6e0a12SSteven Whitehouse } 10649e6e0a12SSteven Whitehouse 10659e6e0a12SSteven Whitehouse static int is_ancestor(const struct dentry *d1, const struct dentry *d2) 10669e6e0a12SSteven Whitehouse { 10679e6e0a12SSteven Whitehouse do { 10689e6e0a12SSteven Whitehouse if (d1 == d2) 10699e6e0a12SSteven Whitehouse return 1; 10709e6e0a12SSteven Whitehouse d1 = d1->d_parent; 10719e6e0a12SSteven Whitehouse } while (!IS_ROOT(d1)); 10729e6e0a12SSteven Whitehouse return 0; 10739e6e0a12SSteven Whitehouse } 10749e6e0a12SSteven Whitehouse 10759e6e0a12SSteven Whitehouse /** 10769e6e0a12SSteven Whitehouse * gfs2_show_options - Show mount options for /proc/mounts 10779e6e0a12SSteven Whitehouse * @s: seq_file structure 107834c80b1dSAl Viro * @root: root of this (sub)tree 10799e6e0a12SSteven Whitehouse * 10809e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 10819e6e0a12SSteven Whitehouse */ 10829e6e0a12SSteven Whitehouse 108334c80b1dSAl Viro static int gfs2_show_options(struct seq_file *s, struct dentry *root) 10849e6e0a12SSteven Whitehouse { 108534c80b1dSAl Viro struct gfs2_sbd *sdp = root->d_sb->s_fs_info; 10869e6e0a12SSteven Whitehouse struct gfs2_args *args = &sdp->sd_args; 10873d3c10f2SBenjamin Marzinski int val; 10889e6e0a12SSteven Whitehouse 108934c80b1dSAl Viro if (is_ancestor(root, sdp->sd_master_dir)) 1090eaebdedcSFabian Frederick seq_puts(s, ",meta"); 10919e6e0a12SSteven Whitehouse if (args->ar_lockproto[0]) 1092a068acf2SKees Cook seq_show_option(s, "lockproto", args->ar_lockproto); 10939e6e0a12SSteven Whitehouse if (args->ar_locktable[0]) 1094a068acf2SKees Cook seq_show_option(s, "locktable", args->ar_locktable); 10959e6e0a12SSteven Whitehouse if (args->ar_hostdata[0]) 1096a068acf2SKees Cook seq_show_option(s, "hostdata", args->ar_hostdata); 10979e6e0a12SSteven Whitehouse if (args->ar_spectator) 1098eaebdedcSFabian Frederick seq_puts(s, ",spectator"); 10999e6e0a12SSteven Whitehouse if (args->ar_localflocks) 1100eaebdedcSFabian Frederick seq_puts(s, ",localflocks"); 11019e6e0a12SSteven Whitehouse if (args->ar_debug) 1102eaebdedcSFabian Frederick seq_puts(s, ",debug"); 11039e6e0a12SSteven Whitehouse if (args->ar_posix_acl) 1104eaebdedcSFabian Frederick seq_puts(s, ",acl"); 11059e6e0a12SSteven Whitehouse if (args->ar_quota != GFS2_QUOTA_DEFAULT) { 11069e6e0a12SSteven Whitehouse char *state; 11079e6e0a12SSteven Whitehouse switch (args->ar_quota) { 11089e6e0a12SSteven Whitehouse case GFS2_QUOTA_OFF: 11099e6e0a12SSteven Whitehouse state = "off"; 11109e6e0a12SSteven Whitehouse break; 11119e6e0a12SSteven Whitehouse case GFS2_QUOTA_ACCOUNT: 11129e6e0a12SSteven Whitehouse state = "account"; 11139e6e0a12SSteven Whitehouse break; 11149e6e0a12SSteven Whitehouse case GFS2_QUOTA_ON: 11159e6e0a12SSteven Whitehouse state = "on"; 11169e6e0a12SSteven Whitehouse break; 11179e6e0a12SSteven Whitehouse default: 11189e6e0a12SSteven Whitehouse state = "unknown"; 11199e6e0a12SSteven Whitehouse break; 11209e6e0a12SSteven Whitehouse } 11219e6e0a12SSteven Whitehouse seq_printf(s, ",quota=%s", state); 11229e6e0a12SSteven Whitehouse } 11239e6e0a12SSteven Whitehouse if (args->ar_suiddir) 1124eaebdedcSFabian Frederick seq_puts(s, ",suiddir"); 11259e6e0a12SSteven Whitehouse if (args->ar_data != GFS2_DATA_DEFAULT) { 11269e6e0a12SSteven Whitehouse char *state; 11279e6e0a12SSteven Whitehouse switch (args->ar_data) { 11289e6e0a12SSteven Whitehouse case GFS2_DATA_WRITEBACK: 11299e6e0a12SSteven Whitehouse state = "writeback"; 11309e6e0a12SSteven Whitehouse break; 11319e6e0a12SSteven Whitehouse case GFS2_DATA_ORDERED: 11329e6e0a12SSteven Whitehouse state = "ordered"; 11339e6e0a12SSteven Whitehouse break; 11349e6e0a12SSteven Whitehouse default: 11359e6e0a12SSteven Whitehouse state = "unknown"; 11369e6e0a12SSteven Whitehouse break; 11379e6e0a12SSteven Whitehouse } 11389e6e0a12SSteven Whitehouse seq_printf(s, ",data=%s", state); 11399e6e0a12SSteven Whitehouse } 11409e6e0a12SSteven Whitehouse if (args->ar_discard) 1141eaebdedcSFabian Frederick seq_puts(s, ",discard"); 11425e687eacSBenjamin Marzinski val = sdp->sd_tune.gt_logd_secs; 11435e687eacSBenjamin Marzinski if (val != 30) 11443d3c10f2SBenjamin Marzinski seq_printf(s, ",commit=%d", val); 11453d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_statfs_quantum; 11463d3c10f2SBenjamin Marzinski if (val != 30) 11473d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_quantum=%d", val); 11482b9731e8SSteven Whitehouse else if (sdp->sd_tune.gt_statfs_slow) 11492b9731e8SSteven Whitehouse seq_puts(s, ",statfs_quantum=0"); 11503d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_quota_quantum; 11513d3c10f2SBenjamin Marzinski if (val != 60) 11523d3c10f2SBenjamin Marzinski seq_printf(s, ",quota_quantum=%d", val); 11533d3c10f2SBenjamin Marzinski if (args->ar_statfs_percent) 11543d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_percent=%d", args->ar_statfs_percent); 1155d34843d0SBob Peterson if (args->ar_errors != GFS2_ERRORS_DEFAULT) { 1156d34843d0SBob Peterson const char *state; 1157d34843d0SBob Peterson 1158d34843d0SBob Peterson switch (args->ar_errors) { 1159d34843d0SBob Peterson case GFS2_ERRORS_WITHDRAW: 1160d34843d0SBob Peterson state = "withdraw"; 1161d34843d0SBob Peterson break; 1162d34843d0SBob Peterson case GFS2_ERRORS_PANIC: 1163d34843d0SBob Peterson state = "panic"; 1164d34843d0SBob Peterson break; 1165d34843d0SBob Peterson default: 1166d34843d0SBob Peterson state = "unknown"; 1167d34843d0SBob Peterson break; 1168d34843d0SBob Peterson } 1169d34843d0SBob Peterson seq_printf(s, ",errors=%s", state); 1170d34843d0SBob Peterson } 1171cdcfde62SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) 1172eaebdedcSFabian Frederick seq_puts(s, ",nobarrier"); 1173913a71d2SSteven Whitehouse if (test_bit(SDF_DEMOTE, &sdp->sd_flags)) 1174eaebdedcSFabian Frederick seq_puts(s, ",demote_interface_used"); 117590306c41SBenjamin Marzinski if (args->ar_rgrplvb) 1176eaebdedcSFabian Frederick seq_puts(s, ",rgrplvb"); 1177471f3db2SBenjamin Marzinski if (args->ar_loccookie) 1178471f3db2SBenjamin Marzinski seq_puts(s, ",loccookie"); 11799e6e0a12SSteven Whitehouse return 0; 11809e6e0a12SSteven Whitehouse } 11819e6e0a12SSteven Whitehouse 1182f42ab085SSteven Whitehouse static void gfs2_final_release_pages(struct gfs2_inode *ip) 1183f42ab085SSteven Whitehouse { 1184f42ab085SSteven Whitehouse struct inode *inode = &ip->i_inode; 1185f42ab085SSteven Whitehouse struct gfs2_glock *gl = ip->i_gl; 1186f42ab085SSteven Whitehouse 1187f42ab085SSteven Whitehouse truncate_inode_pages(gfs2_glock2aspace(ip->i_gl), 0); 1188f42ab085SSteven Whitehouse truncate_inode_pages(&inode->i_data, 0); 1189f42ab085SSteven Whitehouse 1190638803d4SBob Peterson if (atomic_read(&gl->gl_revokes) == 0) { 1191f42ab085SSteven Whitehouse clear_bit(GLF_LFLUSH, &gl->gl_flags); 1192f42ab085SSteven Whitehouse clear_bit(GLF_DIRTY, &gl->gl_flags); 1193f42ab085SSteven Whitehouse } 1194f42ab085SSteven Whitehouse } 1195f42ab085SSteven Whitehouse 1196f42ab085SSteven Whitehouse static int gfs2_dinode_dealloc(struct gfs2_inode *ip) 1197f42ab085SSteven Whitehouse { 1198f42ab085SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1199f42ab085SSteven Whitehouse struct gfs2_rgrpd *rgd; 1200564e12b1SBob Peterson struct gfs2_holder gh; 1201f42ab085SSteven Whitehouse int error; 1202f42ab085SSteven Whitehouse 1203f42ab085SSteven Whitehouse if (gfs2_get_inode_blocks(&ip->i_inode) != 1) { 120494fb763bSSteven Whitehouse gfs2_consist_inode(ip); 1205f42ab085SSteven Whitehouse return -EIO; 1206f42ab085SSteven Whitehouse } 1207f42ab085SSteven Whitehouse 12088e2e0047SBob Peterson error = gfs2_rindex_update(sdp); 12098e2e0047SBob Peterson if (error) 12108e2e0047SBob Peterson return error; 1211f42ab085SSteven Whitehouse 1212f4108a60SEric W. Biederman error = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE); 1213f42ab085SSteven Whitehouse if (error) 12145407e242SBob Peterson return error; 1215f42ab085SSteven Whitehouse 121666fc061bSSteven Whitehouse rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1); 1217f42ab085SSteven Whitehouse if (!rgd) { 1218f42ab085SSteven Whitehouse gfs2_consist_inode(ip); 1219f42ab085SSteven Whitehouse error = -EIO; 12208339ee54SSteven Whitehouse goto out_qs; 1221f42ab085SSteven Whitehouse } 1222f42ab085SSteven Whitehouse 1223564e12b1SBob Peterson error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh); 1224f42ab085SSteven Whitehouse if (error) 12258339ee54SSteven Whitehouse goto out_qs; 1226f42ab085SSteven Whitehouse 12274667a0ecSSteven Whitehouse error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 12284667a0ecSSteven Whitehouse sdp->sd_jdesc->jd_blocks); 1229f42ab085SSteven Whitehouse if (error) 1230f42ab085SSteven Whitehouse goto out_rg_gunlock; 1231f42ab085SSteven Whitehouse 1232f42ab085SSteven Whitehouse gfs2_free_di(rgd, ip); 1233f42ab085SSteven Whitehouse 1234f42ab085SSteven Whitehouse gfs2_final_release_pages(ip); 1235f42ab085SSteven Whitehouse 1236f42ab085SSteven Whitehouse gfs2_trans_end(sdp); 1237f42ab085SSteven Whitehouse 1238f42ab085SSteven Whitehouse out_rg_gunlock: 1239564e12b1SBob Peterson gfs2_glock_dq_uninit(&gh); 1240f42ab085SSteven Whitehouse out_qs: 1241f42ab085SSteven Whitehouse gfs2_quota_unhold(ip); 1242f42ab085SSteven Whitehouse return error; 1243f42ab085SSteven Whitehouse } 1244f42ab085SSteven Whitehouse 1245380f7c65SSteven Whitehouse /** 124671c1b213SAndreas Gruenbacher * gfs2_glock_put_eventually 124771c1b213SAndreas Gruenbacher * @gl: The glock to put 124871c1b213SAndreas Gruenbacher * 124971c1b213SAndreas Gruenbacher * When under memory pressure, trigger a deferred glock put to make sure we 125071c1b213SAndreas Gruenbacher * won't call into DLM and deadlock. Otherwise, put the glock directly. 125171c1b213SAndreas Gruenbacher */ 125271c1b213SAndreas Gruenbacher 125371c1b213SAndreas Gruenbacher static void gfs2_glock_put_eventually(struct gfs2_glock *gl) 125471c1b213SAndreas Gruenbacher { 125571c1b213SAndreas Gruenbacher if (current->flags & PF_MEMALLOC) 125671c1b213SAndreas Gruenbacher gfs2_glock_queue_put(gl); 125771c1b213SAndreas Gruenbacher else 125871c1b213SAndreas Gruenbacher gfs2_glock_put(gl); 125971c1b213SAndreas Gruenbacher } 126071c1b213SAndreas Gruenbacher 12619e73330fSAndreas Gruenbacher static bool gfs2_upgrade_iopen_glock(struct inode *inode) 12629e73330fSAndreas Gruenbacher { 12639e73330fSAndreas Gruenbacher struct gfs2_inode *ip = GFS2_I(inode); 12649e73330fSAndreas Gruenbacher struct gfs2_sbd *sdp = GFS2_SB(inode); 12659e73330fSAndreas Gruenbacher struct gfs2_holder *gh = &ip->i_iopen_gh; 12669e73330fSAndreas Gruenbacher long timeout = 5 * HZ; 12679e73330fSAndreas Gruenbacher int error; 12689e73330fSAndreas Gruenbacher 12699e73330fSAndreas Gruenbacher gh->gh_flags |= GL_NOCACHE; 12709e73330fSAndreas Gruenbacher gfs2_glock_dq_wait(gh); 12719e73330fSAndreas Gruenbacher 12729e73330fSAndreas Gruenbacher /* 12739e73330fSAndreas Gruenbacher * If there are no other lock holders, we'll get the lock immediately. 12749e73330fSAndreas Gruenbacher * Otherwise, the other nodes holding the lock will be notified about 12759e73330fSAndreas Gruenbacher * our locking request. If they don't have the inode open, they'll 12769e73330fSAndreas Gruenbacher * evict the cached inode and release the lock. As a last resort, 12779e73330fSAndreas Gruenbacher * we'll eventually time out. 12789e73330fSAndreas Gruenbacher * 12799e73330fSAndreas Gruenbacher * Note that we're passing the LM_FLAG_TRY_1CB flag to the first 12809e73330fSAndreas Gruenbacher * locking request as an optimization to notify lock holders as soon as 12819e73330fSAndreas Gruenbacher * possible. Without that flag, they'd be notified implicitly by the 12829e73330fSAndreas Gruenbacher * second locking request. 12839e73330fSAndreas Gruenbacher */ 12849e73330fSAndreas Gruenbacher 12859e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, gh); 12869e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 12879e73330fSAndreas Gruenbacher if (error != GLR_TRYFAILED) 12889e73330fSAndreas Gruenbacher return !error; 12899e73330fSAndreas Gruenbacher 12909e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, GL_ASYNC | GL_NOCACHE, gh); 12919e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 12929e73330fSAndreas Gruenbacher if (error) 12939e73330fSAndreas Gruenbacher return false; 12949e73330fSAndreas Gruenbacher 12959e73330fSAndreas Gruenbacher timeout = wait_event_interruptible_timeout(sdp->sd_async_glock_wait, 12969e73330fSAndreas Gruenbacher !test_bit(HIF_WAIT, &gh->gh_iflags), 12979e73330fSAndreas Gruenbacher timeout); 12989e73330fSAndreas Gruenbacher if (!test_bit(HIF_HOLDER, &gh->gh_iflags)) { 12999e73330fSAndreas Gruenbacher gfs2_glock_dq(gh); 13009e73330fSAndreas Gruenbacher return false; 13019e73330fSAndreas Gruenbacher } 13029e73330fSAndreas Gruenbacher return true; 13039e73330fSAndreas Gruenbacher } 13049e73330fSAndreas Gruenbacher 130571c1b213SAndreas Gruenbacher /** 1306380f7c65SSteven Whitehouse * gfs2_evict_inode - Remove an inode from cache 1307380f7c65SSteven Whitehouse * @inode: The inode to evict 1308380f7c65SSteven Whitehouse * 1309380f7c65SSteven Whitehouse * There are three cases to consider: 1310380f7c65SSteven Whitehouse * 1. i_nlink == 0, we are final opener (and must deallocate) 1311380f7c65SSteven Whitehouse * 2. i_nlink == 0, we are not the final opener (and cannot deallocate) 1312380f7c65SSteven Whitehouse * 3. i_nlink > 0 1313380f7c65SSteven Whitehouse * 1314380f7c65SSteven Whitehouse * If the fs is read only, then we have to treat all cases as per #3 1315380f7c65SSteven Whitehouse * since we are unable to do any deallocation. The inode will be 1316380f7c65SSteven Whitehouse * deallocated by the next read/write node to attempt an allocation 1317380f7c65SSteven Whitehouse * in the same resource group 1318380f7c65SSteven Whitehouse * 13199e6e0a12SSteven Whitehouse * We have to (at the moment) hold the inodes main lock to cover 13209e6e0a12SSteven Whitehouse * the gap between unlocking the shared lock on the iopen lock and 13219e6e0a12SSteven Whitehouse * taking the exclusive lock. I'd rather do a shared -> exclusive 13229e6e0a12SSteven Whitehouse * conversion on the iopen lock, but we can change that later. This 13239e6e0a12SSteven Whitehouse * is safe, just less efficient. 13249e6e0a12SSteven Whitehouse */ 13259e6e0a12SSteven Whitehouse 1326d5c1515cSAl Viro static void gfs2_evict_inode(struct inode *inode) 13279e6e0a12SSteven Whitehouse { 1328001e8e8dSSteven Whitehouse struct super_block *sb = inode->i_sb; 1329001e8e8dSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 13309e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 13319e6e0a12SSteven Whitehouse struct gfs2_holder gh; 1332ee530beaSBob Peterson struct address_space *metamapping; 13339e6e0a12SSteven Whitehouse int error; 13349e6e0a12SSteven Whitehouse 133505978803SAbhi Das if (test_bit(GIF_FREE_VFS_INODE, &ip->i_flags)) { 133605978803SAbhi Das clear_inode(inode); 133705978803SAbhi Das return; 133805978803SAbhi Das } 133905978803SAbhi Das 1340bc98a42cSDavid Howells if (inode->i_nlink || sb_rdonly(sb)) 1341d5c1515cSAl Viro goto out; 1342d5c1515cSAl Viro 1343e0b62e21SAndreas Gruenbacher if (test_bit(GIF_ALLOC_FAILED, &ip->i_flags)) { 1344e0b62e21SAndreas Gruenbacher BUG_ON(!gfs2_glock_is_locked_by_me(ip->i_gl)); 1345e0b62e21SAndreas Gruenbacher gfs2_holder_mark_uninitialized(&gh); 13468c7b9262SAndreas Gruenbacher goto out_delete; 1347e0b62e21SAndreas Gruenbacher } 1348e0b62e21SAndreas Gruenbacher 13498c7b9262SAndreas Gruenbacher if (test_bit(GIF_DEFERRED_DELETE, &ip->i_flags)) 13508c7b9262SAndreas Gruenbacher goto out; 13518c7b9262SAndreas Gruenbacher 13526a1c8f6dSAndreas Gruenbacher /* Deletes should never happen under memory pressure anymore. */ 13536a1c8f6dSAndreas Gruenbacher if (WARN_ON_ONCE(current->flags & PF_MEMALLOC)) 13546a1c8f6dSAndreas Gruenbacher goto out; 13556a1c8f6dSAndreas Gruenbacher 135644ad37d6SBob Peterson /* Must not read inode block until block type has been verified */ 135744ad37d6SBob Peterson error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, &gh); 13589e6e0a12SSteven Whitehouse if (unlikely(error)) { 1359240c6235SBob Peterson glock_clear_object(ip->i_iopen_gh.gh_gl, ip); 1360a6a4d98bSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 1361d4da3198SAndreas Gruenbacher gfs2_glock_dq_uninit(&ip->i_iopen_gh); 13629e6e0a12SSteven Whitehouse goto out; 13639e6e0a12SSteven Whitehouse } 13649e6e0a12SSteven Whitehouse 1365f286d627SAndreas Gruenbacher if (gfs2_inode_already_deleted(ip->i_gl, ip->i_no_formal_ino)) 1366f286d627SAndreas Gruenbacher goto out_truncate; 1367acf7e244SSteven Whitehouse error = gfs2_check_blk_type(sdp, ip->i_no_addr, GFS2_BLKST_UNLINKED); 1368acf7e244SSteven Whitehouse if (error) 1369acf7e244SSteven Whitehouse goto out_truncate; 1370acf7e244SSteven Whitehouse 137144ad37d6SBob Peterson if (test_bit(GIF_INVALID, &ip->i_flags)) { 137244ad37d6SBob Peterson error = gfs2_inode_refresh(ip); 137344ad37d6SBob Peterson if (error) 137444ad37d6SBob Peterson goto out_truncate; 137544ad37d6SBob Peterson } 137644ad37d6SBob Peterson 137771c1b213SAndreas Gruenbacher /* 137871c1b213SAndreas Gruenbacher * The inode may have been recreated in the meantime. 137971c1b213SAndreas Gruenbacher */ 138071c1b213SAndreas Gruenbacher if (inode->i_nlink) 138171c1b213SAndreas Gruenbacher goto out_truncate; 138271c1b213SAndreas Gruenbacher 13838c7b9262SAndreas Gruenbacher out_delete: 13846df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&ip->i_iopen_gh) && 13857508abc4SBob Peterson test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 13869e73330fSAndreas Gruenbacher if (!gfs2_upgrade_iopen_glock(inode)) { 13879e73330fSAndreas Gruenbacher gfs2_holder_uninit(&ip->i_iopen_gh); 13889e6e0a12SSteven Whitehouse goto out_truncate; 13897508abc4SBob Peterson } 13909e73330fSAndreas Gruenbacher } 13919e6e0a12SSteven Whitehouse 13929e6e0a12SSteven Whitehouse if (S_ISDIR(inode->i_mode) && 13939e6e0a12SSteven Whitehouse (ip->i_diskflags & GFS2_DIF_EXHASH)) { 13949e6e0a12SSteven Whitehouse error = gfs2_dir_exhash_dealloc(ip); 13959e6e0a12SSteven Whitehouse if (error) 13969e6e0a12SSteven Whitehouse goto out_unlock; 13979e6e0a12SSteven Whitehouse } 13989e6e0a12SSteven Whitehouse 13999e6e0a12SSteven Whitehouse if (ip->i_eattr) { 14009e6e0a12SSteven Whitehouse error = gfs2_ea_dealloc(ip); 14019e6e0a12SSteven Whitehouse if (error) 14029e6e0a12SSteven Whitehouse goto out_unlock; 14039e6e0a12SSteven Whitehouse } 14049e6e0a12SSteven Whitehouse 14059e6e0a12SSteven Whitehouse if (!gfs2_is_stuffed(ip)) { 14069e6e0a12SSteven Whitehouse error = gfs2_file_dealloc(ip); 14079e6e0a12SSteven Whitehouse if (error) 14089e6e0a12SSteven Whitehouse goto out_unlock; 14099e6e0a12SSteven Whitehouse } 14109e6e0a12SSteven Whitehouse 1411240c6235SBob Peterson /* We're about to clear the bitmap for the dinode, but as soon as we 1412240c6235SBob Peterson do, gfs2_create_inode can create another inode at the same block 1413240c6235SBob Peterson location and try to set gl_object again. We clear gl_object here so 1414240c6235SBob Peterson that subsequent inode creates don't see an old gl_object. */ 1415240c6235SBob Peterson glock_clear_object(ip->i_gl, ip); 14169e6e0a12SSteven Whitehouse error = gfs2_dinode_dealloc(ip); 1417f286d627SAndreas Gruenbacher gfs2_inode_remember_delete(ip->i_gl, ip->i_no_formal_ino); 14189e6e0a12SSteven Whitehouse goto out_unlock; 14199e6e0a12SSteven Whitehouse 14209e6e0a12SSteven Whitehouse out_truncate: 1421805c0907SBob Peterson gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL | 1422805c0907SBob Peterson GFS2_LFC_EVICT_INODE); 1423ee530beaSBob Peterson metamapping = gfs2_glock2aspace(ip->i_gl); 14242216db70SBenjamin Marzinski if (test_bit(GLF_DIRTY, &ip->i_gl->gl_flags)) { 14252216db70SBenjamin Marzinski filemap_fdatawrite(metamapping); 14262216db70SBenjamin Marzinski filemap_fdatawait(metamapping); 14272216db70SBenjamin Marzinski } 142840ac218fSSteven Whitehouse write_inode_now(inode, 1); 1429b5b24d7aSSteven Whitehouse gfs2_ail_flush(ip->i_gl, 0); 143040ac218fSSteven Whitehouse 14319e6e0a12SSteven Whitehouse error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks); 14329e6e0a12SSteven Whitehouse if (error) 14339e6e0a12SSteven Whitehouse goto out_unlock; 1434380f7c65SSteven Whitehouse /* Needs to be done before glock release & also in a transaction */ 1435380f7c65SSteven Whitehouse truncate_inode_pages(&inode->i_data, 0); 1436ee530beaSBob Peterson truncate_inode_pages(metamapping, 0); 14379e6e0a12SSteven Whitehouse gfs2_trans_end(sdp); 14389e6e0a12SSteven Whitehouse 14399e6e0a12SSteven Whitehouse out_unlock: 1440a097dc7eSBob Peterson if (gfs2_rs_active(&ip->i_res)) 1441a097dc7eSBob Peterson gfs2_rs_deltree(&ip->i_res); 14428e2e0047SBob Peterson 1443240c6235SBob Peterson if (gfs2_holder_initialized(&gh)) { 1444240c6235SBob Peterson glock_clear_object(ip->i_gl, ip); 14459e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 1446240c6235SBob Peterson } 14479e6e0a12SSteven Whitehouse if (error && error != GLR_TRYFAILED && error != -EROFS) 1448d5c1515cSAl Viro fs_warn(sdp, "gfs2_evict_inode: %d\n", error); 14499e6e0a12SSteven Whitehouse out: 145091b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 14512fba46a0SBob Peterson if (ip->i_qadata) 14522fba46a0SBob Peterson gfs2_assert_warn(sdp, ip->i_qadata->qa_ref == 0); 14531595548fSAndreas Gruenbacher gfs2_rs_delete(ip, NULL); 145445138990SSteven Whitehouse gfs2_ordered_del_inode(ip); 1455dbd5768fSJan Kara clear_inode(inode); 145617d539f0SSteven Whitehouse gfs2_dir_hash_inval(ip); 145740e7e86eSAndreas Gruenbacher if (ip->i_gl) { 1458df3d87bdSBob Peterson glock_clear_object(ip->i_gl, ip); 14594fd1a579SAndreas Gruenbacher wait_on_bit_io(&ip->i_flags, GIF_GLOP_PENDING, TASK_UNINTERRUPTIBLE); 146029687a2aSSteven Whitehouse gfs2_glock_add_to_lru(ip->i_gl); 146171c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(ip->i_gl); 1462d5c1515cSAl Viro ip->i_gl = NULL; 146340e7e86eSAndreas Gruenbacher } 14646df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&ip->i_iopen_gh)) { 146571c1b213SAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 146671c1b213SAndreas Gruenbacher 146771c1b213SAndreas Gruenbacher glock_clear_object(gl, ip); 146840e7e86eSAndreas Gruenbacher if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 1469a6a4d98bSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 147040e7e86eSAndreas Gruenbacher gfs2_glock_dq(&ip->i_iopen_gh); 147140e7e86eSAndreas Gruenbacher } 147271c1b213SAndreas Gruenbacher gfs2_glock_hold(gl); 147340e7e86eSAndreas Gruenbacher gfs2_holder_uninit(&ip->i_iopen_gh); 147471c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(gl); 1475d5c1515cSAl Viro } 14769e6e0a12SSteven Whitehouse } 14779e6e0a12SSteven Whitehouse 14789e6e0a12SSteven Whitehouse static struct inode *gfs2_alloc_inode(struct super_block *sb) 14799e6e0a12SSteven Whitehouse { 14809e6e0a12SSteven Whitehouse struct gfs2_inode *ip; 14819e6e0a12SSteven Whitehouse 14829e6e0a12SSteven Whitehouse ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL); 1483d4031259SAndreas Gruenbacher if (!ip) 1484d4031259SAndreas Gruenbacher return NULL; 14859e6e0a12SSteven Whitehouse ip->i_flags = 0; 14869e6e0a12SSteven Whitehouse ip->i_gl = NULL; 148740e7e86eSAndreas Gruenbacher gfs2_holder_mark_uninitialized(&ip->i_iopen_gh); 1488a097dc7eSBob Peterson memset(&ip->i_res, 0, sizeof(ip->i_res)); 1489a097dc7eSBob Peterson RB_CLEAR_NODE(&ip->i_res.rs_node); 1490c8d57703SAndreas Gruenbacher ip->i_rahead = 0; 14919e6e0a12SSteven Whitehouse return &ip->i_inode; 14929e6e0a12SSteven Whitehouse } 14939e6e0a12SSteven Whitehouse 1494784494e1SAl Viro static void gfs2_free_inode(struct inode *inode) 1495fa0d7e3dSNick Piggin { 1496784494e1SAl Viro kmem_cache_free(gfs2_inode_cachep, GFS2_I(inode)); 14979e6e0a12SSteven Whitehouse } 14989e6e0a12SSteven Whitehouse 14999e6e0a12SSteven Whitehouse const struct super_operations gfs2_super_ops = { 15009e6e0a12SSteven Whitehouse .alloc_inode = gfs2_alloc_inode, 1501784494e1SAl Viro .free_inode = gfs2_free_inode, 15029e6e0a12SSteven Whitehouse .write_inode = gfs2_write_inode, 1503ab9bbda0SSteven Whitehouse .dirty_inode = gfs2_dirty_inode, 1504d5c1515cSAl Viro .evict_inode = gfs2_evict_inode, 15059e6e0a12SSteven Whitehouse .put_super = gfs2_put_super, 15069e6e0a12SSteven Whitehouse .sync_fs = gfs2_sync_fs, 15072e60d768SBenjamin Marzinski .freeze_super = gfs2_freeze, 15082e60d768SBenjamin Marzinski .thaw_super = gfs2_unfreeze, 15099e6e0a12SSteven Whitehouse .statfs = gfs2_statfs, 15109e6e0a12SSteven Whitehouse .drop_inode = gfs2_drop_inode, 15119e6e0a12SSteven Whitehouse .show_options = gfs2_show_options, 15129e6e0a12SSteven Whitehouse }; 15139e6e0a12SSteven Whitehouse 1514