inode.c 213 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065
  1. /*
  2. * Copyright (C) 2007 Oracle. All rights reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public
  6. * License v2 as published by the Free Software Foundation.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11. * General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public
  14. * License along with this program; if not, write to the
  15. * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16. * Boston, MA 021110-1307, USA.
  17. */
  18. #include <linux/kernel.h>
  19. #include <linux/bio.h>
  20. #include <linux/buffer_head.h>
  21. #include <linux/file.h>
  22. #include <linux/fs.h>
  23. #include <linux/pagemap.h>
  24. #include <linux/highmem.h>
  25. #include <linux/time.h>
  26. #include <linux/init.h>
  27. #include <linux/string.h>
  28. #include <linux/backing-dev.h>
  29. #include <linux/mpage.h>
  30. #include <linux/swap.h>
  31. #include <linux/writeback.h>
  32. #include <linux/statfs.h>
  33. #include <linux/compat.h>
  34. #include <linux/bit_spinlock.h>
  35. #include <linux/xattr.h>
  36. #include <linux/posix_acl.h>
  37. #include <linux/falloc.h>
  38. #include <linux/slab.h>
  39. #include <linux/ratelimit.h>
  40. #include <linux/mount.h>
  41. #include "compat.h"
  42. #include "ctree.h"
  43. #include "disk-io.h"
  44. #include "transaction.h"
  45. #include "btrfs_inode.h"
  46. #include "ioctl.h"
  47. #include "print-tree.h"
  48. #include "ordered-data.h"
  49. #include "xattr.h"
  50. #include "tree-log.h"
  51. #include "volumes.h"
  52. #include "compression.h"
  53. #include "locking.h"
  54. #include "free-space-cache.h"
  55. #include "inode-map.h"
  56. struct btrfs_iget_args {
  57. u64 ino;
  58. struct btrfs_root *root;
  59. };
  60. static const struct inode_operations btrfs_dir_inode_operations;
  61. static const struct inode_operations btrfs_symlink_inode_operations;
  62. static const struct inode_operations btrfs_dir_ro_inode_operations;
  63. static const struct inode_operations btrfs_special_inode_operations;
  64. static const struct inode_operations btrfs_file_inode_operations;
  65. static const struct address_space_operations btrfs_aops;
  66. static const struct address_space_operations btrfs_symlink_aops;
  67. static const struct file_operations btrfs_dir_file_operations;
  68. static struct extent_io_ops btrfs_extent_io_ops;
  69. static struct kmem_cache *btrfs_inode_cachep;
  70. static struct kmem_cache *btrfs_delalloc_work_cachep;
  71. struct kmem_cache *btrfs_trans_handle_cachep;
  72. struct kmem_cache *btrfs_transaction_cachep;
  73. struct kmem_cache *btrfs_path_cachep;
  74. struct kmem_cache *btrfs_free_space_cachep;
  75. #define S_SHIFT 12
  76. static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  77. [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
  78. [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
  79. [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
  80. [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
  81. [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
  82. [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
  83. [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
  84. };
  85. static int btrfs_setsize(struct inode *inode, struct iattr *attr);
  86. static int btrfs_truncate(struct inode *inode);
  87. static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
  88. static noinline int cow_file_range(struct inode *inode,
  89. struct page *locked_page,
  90. u64 start, u64 end, int *page_started,
  91. unsigned long *nr_written, int unlock);
  92. static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
  93. u64 len, u64 orig_start,
  94. u64 block_start, u64 block_len,
  95. u64 orig_block_len, int type);
  96. static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
  97. struct inode *inode, struct inode *dir,
  98. const struct qstr *qstr)
  99. {
  100. int err;
  101. err = btrfs_init_acl(trans, inode, dir);
  102. if (!err)
  103. err = btrfs_xattr_security_init(trans, inode, dir, qstr);
  104. return err;
  105. }
  106. /*
  107. * this does all the hard work for inserting an inline extent into
  108. * the btree. The caller should have done a btrfs_drop_extents so that
  109. * no overlapping inline items exist in the btree
  110. */
  111. static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
  112. struct btrfs_root *root, struct inode *inode,
  113. u64 start, size_t size, size_t compressed_size,
  114. int compress_type,
  115. struct page **compressed_pages)
  116. {
  117. struct btrfs_key key;
  118. struct btrfs_path *path;
  119. struct extent_buffer *leaf;
  120. struct page *page = NULL;
  121. char *kaddr;
  122. unsigned long ptr;
  123. struct btrfs_file_extent_item *ei;
  124. int err = 0;
  125. int ret;
  126. size_t cur_size = size;
  127. size_t datasize;
  128. unsigned long offset;
  129. if (compressed_size && compressed_pages)
  130. cur_size = compressed_size;
  131. path = btrfs_alloc_path();
  132. if (!path)
  133. return -ENOMEM;
  134. path->leave_spinning = 1;
  135. key.objectid = btrfs_ino(inode);
  136. key.offset = start;
  137. btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
  138. datasize = btrfs_file_extent_calc_inline_size(cur_size);
  139. inode_add_bytes(inode, size);
  140. ret = btrfs_insert_empty_item(trans, root, path, &key,
  141. datasize);
  142. if (ret) {
  143. err = ret;
  144. goto fail;
  145. }
  146. leaf = path->nodes[0];
  147. ei = btrfs_item_ptr(leaf, path->slots[0],
  148. struct btrfs_file_extent_item);
  149. btrfs_set_file_extent_generation(leaf, ei, trans->transid);
  150. btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
  151. btrfs_set_file_extent_encryption(leaf, ei, 0);
  152. btrfs_set_file_extent_other_encoding(leaf, ei, 0);
  153. btrfs_set_file_extent_ram_bytes(leaf, ei, size);
  154. ptr = btrfs_file_extent_inline_start(ei);
  155. if (compress_type != BTRFS_COMPRESS_NONE) {
  156. struct page *cpage;
  157. int i = 0;
  158. while (compressed_size > 0) {
  159. cpage = compressed_pages[i];
  160. cur_size = min_t(unsigned long, compressed_size,
  161. PAGE_CACHE_SIZE);
  162. kaddr = kmap_atomic(cpage);
  163. write_extent_buffer(leaf, kaddr, ptr, cur_size);
  164. kunmap_atomic(kaddr);
  165. i++;
  166. ptr += cur_size;
  167. compressed_size -= cur_size;
  168. }
  169. btrfs_set_file_extent_compression(leaf, ei,
  170. compress_type);
  171. } else {
  172. page = find_get_page(inode->i_mapping,
  173. start >> PAGE_CACHE_SHIFT);
  174. btrfs_set_file_extent_compression(leaf, ei, 0);
  175. kaddr = kmap_atomic(page);
  176. offset = start & (PAGE_CACHE_SIZE - 1);
  177. write_extent_buffer(leaf, kaddr + offset, ptr, size);
  178. kunmap_atomic(kaddr);
  179. page_cache_release(page);
  180. }
  181. btrfs_mark_buffer_dirty(leaf);
  182. btrfs_free_path(path);
  183. /*
  184. * we're an inline extent, so nobody can
  185. * extend the file past i_size without locking
  186. * a page we already have locked.
  187. *
  188. * We must do any isize and inode updates
  189. * before we unlock the pages. Otherwise we
  190. * could end up racing with unlink.
  191. */
  192. BTRFS_I(inode)->disk_i_size = inode->i_size;
  193. ret = btrfs_update_inode(trans, root, inode);
  194. return ret;
  195. fail:
  196. btrfs_free_path(path);
  197. return err;
  198. }
  199. /*
  200. * conditionally insert an inline extent into the file. This
  201. * does the checks required to make sure the data is small enough
  202. * to fit as an inline extent.
  203. */
  204. static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
  205. struct btrfs_root *root,
  206. struct inode *inode, u64 start, u64 end,
  207. size_t compressed_size, int compress_type,
  208. struct page **compressed_pages)
  209. {
  210. u64 isize = i_size_read(inode);
  211. u64 actual_end = min(end + 1, isize);
  212. u64 inline_len = actual_end - start;
  213. u64 aligned_end = (end + root->sectorsize - 1) &
  214. ~((u64)root->sectorsize - 1);
  215. u64 data_len = inline_len;
  216. int ret;
  217. if (compressed_size)
  218. data_len = compressed_size;
  219. if (start > 0 ||
  220. actual_end >= PAGE_CACHE_SIZE ||
  221. data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
  222. (!compressed_size &&
  223. (actual_end & (root->sectorsize - 1)) == 0) ||
  224. end + 1 < isize ||
  225. data_len > root->fs_info->max_inline) {
  226. return 1;
  227. }
  228. ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
  229. if (ret)
  230. return ret;
  231. if (isize > actual_end)
  232. inline_len = min_t(u64, isize, actual_end);
  233. ret = insert_inline_extent(trans, root, inode, start,
  234. inline_len, compressed_size,
  235. compress_type, compressed_pages);
  236. if (ret && ret != -ENOSPC) {
  237. btrfs_abort_transaction(trans, root, ret);
  238. return ret;
  239. } else if (ret == -ENOSPC) {
  240. return 1;
  241. }
  242. btrfs_delalloc_release_metadata(inode, end + 1 - start);
  243. btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
  244. return 0;
  245. }
  246. struct async_extent {
  247. u64 start;
  248. u64 ram_size;
  249. u64 compressed_size;
  250. struct page **pages;
  251. unsigned long nr_pages;
  252. int compress_type;
  253. struct list_head list;
  254. };
  255. struct async_cow {
  256. struct inode *inode;
  257. struct btrfs_root *root;
  258. struct page *locked_page;
  259. u64 start;
  260. u64 end;
  261. struct list_head extents;
  262. struct btrfs_work work;
  263. };
  264. static noinline int add_async_extent(struct async_cow *cow,
  265. u64 start, u64 ram_size,
  266. u64 compressed_size,
  267. struct page **pages,
  268. unsigned long nr_pages,
  269. int compress_type)
  270. {
  271. struct async_extent *async_extent;
  272. async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
  273. BUG_ON(!async_extent); /* -ENOMEM */
  274. async_extent->start = start;
  275. async_extent->ram_size = ram_size;
  276. async_extent->compressed_size = compressed_size;
  277. async_extent->pages = pages;
  278. async_extent->nr_pages = nr_pages;
  279. async_extent->compress_type = compress_type;
  280. list_add_tail(&async_extent->list, &cow->extents);
  281. return 0;
  282. }
  283. /*
  284. * we create compressed extents in two phases. The first
  285. * phase compresses a range of pages that have already been
  286. * locked (both pages and state bits are locked).
  287. *
  288. * This is done inside an ordered work queue, and the compression
  289. * is spread across many cpus. The actual IO submission is step
  290. * two, and the ordered work queue takes care of making sure that
  291. * happens in the same order things were put onto the queue by
  292. * writepages and friends.
  293. *
  294. * If this code finds it can't get good compression, it puts an
  295. * entry onto the work queue to write the uncompressed bytes. This
  296. * makes sure that both compressed inodes and uncompressed inodes
  297. * are written in the same order that the flusher thread sent them
  298. * down.
  299. */
  300. static noinline int compress_file_range(struct inode *inode,
  301. struct page *locked_page,
  302. u64 start, u64 end,
  303. struct async_cow *async_cow,
  304. int *num_added)
  305. {
  306. struct btrfs_root *root = BTRFS_I(inode)->root;
  307. struct btrfs_trans_handle *trans;
  308. u64 num_bytes;
  309. u64 blocksize = root->sectorsize;
  310. u64 actual_end;
  311. u64 isize = i_size_read(inode);
  312. int ret = 0;
  313. struct page **pages = NULL;
  314. unsigned long nr_pages;
  315. unsigned long nr_pages_ret = 0;
  316. unsigned long total_compressed = 0;
  317. unsigned long total_in = 0;
  318. unsigned long max_compressed = 128 * 1024;
  319. unsigned long max_uncompressed = 128 * 1024;
  320. int i;
  321. int will_compress;
  322. int compress_type = root->fs_info->compress_type;
  323. /* if this is a small write inside eof, kick off a defrag */
  324. if ((end - start + 1) < 16 * 1024 &&
  325. (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
  326. btrfs_add_inode_defrag(NULL, inode);
  327. actual_end = min_t(u64, isize, end + 1);
  328. again:
  329. will_compress = 0;
  330. nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
  331. nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
  332. /*
  333. * we don't want to send crud past the end of i_size through
  334. * compression, that's just a waste of CPU time. So, if the
  335. * end of the file is before the start of our current
  336. * requested range of bytes, we bail out to the uncompressed
  337. * cleanup code that can deal with all of this.
  338. *
  339. * It isn't really the fastest way to fix things, but this is a
  340. * very uncommon corner.
  341. */
  342. if (actual_end <= start)
  343. goto cleanup_and_bail_uncompressed;
  344. total_compressed = actual_end - start;
  345. /* we want to make sure that amount of ram required to uncompress
  346. * an extent is reasonable, so we limit the total size in ram
  347. * of a compressed extent to 128k. This is a crucial number
  348. * because it also controls how easily we can spread reads across
  349. * cpus for decompression.
  350. *
  351. * We also want to make sure the amount of IO required to do
  352. * a random read is reasonably small, so we limit the size of
  353. * a compressed extent to 128k.
  354. */
  355. total_compressed = min(total_compressed, max_uncompressed);
  356. num_bytes = (end - start + blocksize) & ~(blocksize - 1);
  357. num_bytes = max(blocksize, num_bytes);
  358. total_in = 0;
  359. ret = 0;
  360. /*
  361. * we do compression for mount -o compress and when the
  362. * inode has not been flagged as nocompress. This flag can
  363. * change at any time if we discover bad compression ratios.
  364. */
  365. if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
  366. (btrfs_test_opt(root, COMPRESS) ||
  367. (BTRFS_I(inode)->force_compress) ||
  368. (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
  369. WARN_ON(pages);
  370. pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
  371. if (!pages) {
  372. /* just bail out to the uncompressed code */
  373. goto cont;
  374. }
  375. if (BTRFS_I(inode)->force_compress)
  376. compress_type = BTRFS_I(inode)->force_compress;
  377. ret = btrfs_compress_pages(compress_type,
  378. inode->i_mapping, start,
  379. total_compressed, pages,
  380. nr_pages, &nr_pages_ret,
  381. &total_in,
  382. &total_compressed,
  383. max_compressed);
  384. if (!ret) {
  385. unsigned long offset = total_compressed &
  386. (PAGE_CACHE_SIZE - 1);
  387. struct page *page = pages[nr_pages_ret - 1];
  388. char *kaddr;
  389. /* zero the tail end of the last page, we might be
  390. * sending it down to disk
  391. */
  392. if (offset) {
  393. kaddr = kmap_atomic(page);
  394. memset(kaddr + offset, 0,
  395. PAGE_CACHE_SIZE - offset);
  396. kunmap_atomic(kaddr);
  397. }
  398. will_compress = 1;
  399. }
  400. }
  401. cont:
  402. if (start == 0) {
  403. trans = btrfs_join_transaction(root);
  404. if (IS_ERR(trans)) {
  405. ret = PTR_ERR(trans);
  406. trans = NULL;
  407. goto cleanup_and_out;
  408. }
  409. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  410. /* lets try to make an inline extent */
  411. if (ret || total_in < (actual_end - start)) {
  412. /* we didn't compress the entire range, try
  413. * to make an uncompressed inline extent.
  414. */
  415. ret = cow_file_range_inline(trans, root, inode,
  416. start, end, 0, 0, NULL);
  417. } else {
  418. /* try making a compressed inline extent */
  419. ret = cow_file_range_inline(trans, root, inode,
  420. start, end,
  421. total_compressed,
  422. compress_type, pages);
  423. }
  424. if (ret <= 0) {
  425. /*
  426. * inline extent creation worked or returned error,
  427. * we don't need to create any more async work items.
  428. * Unlock and free up our temp pages.
  429. */
  430. extent_clear_unlock_delalloc(inode,
  431. &BTRFS_I(inode)->io_tree,
  432. start, end, NULL,
  433. EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
  434. EXTENT_CLEAR_DELALLOC |
  435. EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
  436. btrfs_end_transaction(trans, root);
  437. goto free_pages_out;
  438. }
  439. btrfs_end_transaction(trans, root);
  440. }
  441. if (will_compress) {
  442. /*
  443. * we aren't doing an inline extent round the compressed size
  444. * up to a block size boundary so the allocator does sane
  445. * things
  446. */
  447. total_compressed = (total_compressed + blocksize - 1) &
  448. ~(blocksize - 1);
  449. /*
  450. * one last check to make sure the compression is really a
  451. * win, compare the page count read with the blocks on disk
  452. */
  453. total_in = (total_in + PAGE_CACHE_SIZE - 1) &
  454. ~(PAGE_CACHE_SIZE - 1);
  455. if (total_compressed >= total_in) {
  456. will_compress = 0;
  457. } else {
  458. num_bytes = total_in;
  459. }
  460. }
  461. if (!will_compress && pages) {
  462. /*
  463. * the compression code ran but failed to make things smaller,
  464. * free any pages it allocated and our page pointer array
  465. */
  466. for (i = 0; i < nr_pages_ret; i++) {
  467. WARN_ON(pages[i]->mapping);
  468. page_cache_release(pages[i]);
  469. }
  470. kfree(pages);
  471. pages = NULL;
  472. total_compressed = 0;
  473. nr_pages_ret = 0;
  474. /* flag the file so we don't compress in the future */
  475. if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
  476. !(BTRFS_I(inode)->force_compress)) {
  477. BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
  478. }
  479. }
  480. if (will_compress) {
  481. *num_added += 1;
  482. /* the async work queues will take care of doing actual
  483. * allocation on disk for these compressed pages,
  484. * and will submit them to the elevator.
  485. */
  486. add_async_extent(async_cow, start, num_bytes,
  487. total_compressed, pages, nr_pages_ret,
  488. compress_type);
  489. if (start + num_bytes < end) {
  490. start += num_bytes;
  491. pages = NULL;
  492. cond_resched();
  493. goto again;
  494. }
  495. } else {
  496. cleanup_and_bail_uncompressed:
  497. /*
  498. * No compression, but we still need to write the pages in
  499. * the file we've been given so far. redirty the locked
  500. * page if it corresponds to our extent and set things up
  501. * for the async work queue to run cow_file_range to do
  502. * the normal delalloc dance
  503. */
  504. if (page_offset(locked_page) >= start &&
  505. page_offset(locked_page) <= end) {
  506. __set_page_dirty_nobuffers(locked_page);
  507. /* unlocked later on in the async handlers */
  508. }
  509. add_async_extent(async_cow, start, end - start + 1,
  510. 0, NULL, 0, BTRFS_COMPRESS_NONE);
  511. *num_added += 1;
  512. }
  513. out:
  514. return ret;
  515. free_pages_out:
  516. for (i = 0; i < nr_pages_ret; i++) {
  517. WARN_ON(pages[i]->mapping);
  518. page_cache_release(pages[i]);
  519. }
  520. kfree(pages);
  521. goto out;
  522. cleanup_and_out:
  523. extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
  524. start, end, NULL,
  525. EXTENT_CLEAR_UNLOCK_PAGE |
  526. EXTENT_CLEAR_DIRTY |
  527. EXTENT_CLEAR_DELALLOC |
  528. EXTENT_SET_WRITEBACK |
  529. EXTENT_END_WRITEBACK);
  530. if (!trans || IS_ERR(trans))
  531. btrfs_error(root->fs_info, ret, "Failed to join transaction");
  532. else
  533. btrfs_abort_transaction(trans, root, ret);
  534. goto free_pages_out;
  535. }
  536. /*
  537. * phase two of compressed writeback. This is the ordered portion
  538. * of the code, which only gets called in the order the work was
  539. * queued. We walk all the async extents created by compress_file_range
  540. * and send them down to the disk.
  541. */
  542. static noinline int submit_compressed_extents(struct inode *inode,
  543. struct async_cow *async_cow)
  544. {
  545. struct async_extent *async_extent;
  546. u64 alloc_hint = 0;
  547. struct btrfs_trans_handle *trans;
  548. struct btrfs_key ins;
  549. struct extent_map *em;
  550. struct btrfs_root *root = BTRFS_I(inode)->root;
  551. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  552. struct extent_io_tree *io_tree;
  553. int ret = 0;
  554. if (list_empty(&async_cow->extents))
  555. return 0;
  556. while (!list_empty(&async_cow->extents)) {
  557. async_extent = list_entry(async_cow->extents.next,
  558. struct async_extent, list);
  559. list_del(&async_extent->list);
  560. io_tree = &BTRFS_I(inode)->io_tree;
  561. retry:
  562. /* did the compression code fall back to uncompressed IO? */
  563. if (!async_extent->pages) {
  564. int page_started = 0;
  565. unsigned long nr_written = 0;
  566. lock_extent(io_tree, async_extent->start,
  567. async_extent->start +
  568. async_extent->ram_size - 1);
  569. /* allocate blocks */
  570. ret = cow_file_range(inode, async_cow->locked_page,
  571. async_extent->start,
  572. async_extent->start +
  573. async_extent->ram_size - 1,
  574. &page_started, &nr_written, 0);
  575. /* JDM XXX */
  576. /*
  577. * if page_started, cow_file_range inserted an
  578. * inline extent and took care of all the unlocking
  579. * and IO for us. Otherwise, we need to submit
  580. * all those pages down to the drive.
  581. */
  582. if (!page_started && !ret)
  583. extent_write_locked_range(io_tree,
  584. inode, async_extent->start,
  585. async_extent->start +
  586. async_extent->ram_size - 1,
  587. btrfs_get_extent,
  588. WB_SYNC_ALL);
  589. kfree(async_extent);
  590. cond_resched();
  591. continue;
  592. }
  593. lock_extent(io_tree, async_extent->start,
  594. async_extent->start + async_extent->ram_size - 1);
  595. trans = btrfs_join_transaction(root);
  596. if (IS_ERR(trans)) {
  597. ret = PTR_ERR(trans);
  598. } else {
  599. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  600. ret = btrfs_reserve_extent(trans, root,
  601. async_extent->compressed_size,
  602. async_extent->compressed_size,
  603. 0, alloc_hint, &ins, 1);
  604. if (ret && ret != -ENOSPC)
  605. btrfs_abort_transaction(trans, root, ret);
  606. btrfs_end_transaction(trans, root);
  607. }
  608. if (ret) {
  609. int i;
  610. for (i = 0; i < async_extent->nr_pages; i++) {
  611. WARN_ON(async_extent->pages[i]->mapping);
  612. page_cache_release(async_extent->pages[i]);
  613. }
  614. kfree(async_extent->pages);
  615. async_extent->nr_pages = 0;
  616. async_extent->pages = NULL;
  617. unlock_extent(io_tree, async_extent->start,
  618. async_extent->start +
  619. async_extent->ram_size - 1);
  620. if (ret == -ENOSPC)
  621. goto retry;
  622. goto out_free; /* JDM: Requeue? */
  623. }
  624. /*
  625. * here we're doing allocation and writeback of the
  626. * compressed pages
  627. */
  628. btrfs_drop_extent_cache(inode, async_extent->start,
  629. async_extent->start +
  630. async_extent->ram_size - 1, 0);
  631. em = alloc_extent_map();
  632. BUG_ON(!em); /* -ENOMEM */
  633. em->start = async_extent->start;
  634. em->len = async_extent->ram_size;
  635. em->orig_start = em->start;
  636. em->block_start = ins.objectid;
  637. em->block_len = ins.offset;
  638. em->orig_block_len = ins.offset;
  639. em->bdev = root->fs_info->fs_devices->latest_bdev;
  640. em->compress_type = async_extent->compress_type;
  641. set_bit(EXTENT_FLAG_PINNED, &em->flags);
  642. set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
  643. em->generation = -1;
  644. while (1) {
  645. write_lock(&em_tree->lock);
  646. ret = add_extent_mapping(em_tree, em);
  647. if (!ret)
  648. list_move(&em->list,
  649. &em_tree->modified_extents);
  650. write_unlock(&em_tree->lock);
  651. if (ret != -EEXIST) {
  652. free_extent_map(em);
  653. break;
  654. }
  655. btrfs_drop_extent_cache(inode, async_extent->start,
  656. async_extent->start +
  657. async_extent->ram_size - 1, 0);
  658. }
  659. ret = btrfs_add_ordered_extent_compress(inode,
  660. async_extent->start,
  661. ins.objectid,
  662. async_extent->ram_size,
  663. ins.offset,
  664. BTRFS_ORDERED_COMPRESSED,
  665. async_extent->compress_type);
  666. BUG_ON(ret); /* -ENOMEM */
  667. /*
  668. * clear dirty, set writeback and unlock the pages.
  669. */
  670. extent_clear_unlock_delalloc(inode,
  671. &BTRFS_I(inode)->io_tree,
  672. async_extent->start,
  673. async_extent->start +
  674. async_extent->ram_size - 1,
  675. NULL, EXTENT_CLEAR_UNLOCK_PAGE |
  676. EXTENT_CLEAR_UNLOCK |
  677. EXTENT_CLEAR_DELALLOC |
  678. EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
  679. ret = btrfs_submit_compressed_write(inode,
  680. async_extent->start,
  681. async_extent->ram_size,
  682. ins.objectid,
  683. ins.offset, async_extent->pages,
  684. async_extent->nr_pages);
  685. BUG_ON(ret); /* -ENOMEM */
  686. alloc_hint = ins.objectid + ins.offset;
  687. kfree(async_extent);
  688. cond_resched();
  689. }
  690. ret = 0;
  691. out:
  692. return ret;
  693. out_free:
  694. kfree(async_extent);
  695. goto out;
  696. }
  697. static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
  698. u64 num_bytes)
  699. {
  700. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  701. struct extent_map *em;
  702. u64 alloc_hint = 0;
  703. read_lock(&em_tree->lock);
  704. em = search_extent_mapping(em_tree, start, num_bytes);
  705. if (em) {
  706. /*
  707. * if block start isn't an actual block number then find the
  708. * first block in this inode and use that as a hint. If that
  709. * block is also bogus then just don't worry about it.
  710. */
  711. if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
  712. free_extent_map(em);
  713. em = search_extent_mapping(em_tree, 0, 0);
  714. if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
  715. alloc_hint = em->block_start;
  716. if (em)
  717. free_extent_map(em);
  718. } else {
  719. alloc_hint = em->block_start;
  720. free_extent_map(em);
  721. }
  722. }
  723. read_unlock(&em_tree->lock);
  724. return alloc_hint;
  725. }
  726. /*
  727. * when extent_io.c finds a delayed allocation range in the file,
  728. * the call backs end up in this code. The basic idea is to
  729. * allocate extents on disk for the range, and create ordered data structs
  730. * in ram to track those extents.
  731. *
  732. * locked_page is the page that writepage had locked already. We use
  733. * it to make sure we don't do extra locks or unlocks.
  734. *
  735. * *page_started is set to one if we unlock locked_page and do everything
  736. * required to start IO on it. It may be clean and already done with
  737. * IO when we return.
  738. */
  739. static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
  740. struct inode *inode,
  741. struct btrfs_root *root,
  742. struct page *locked_page,
  743. u64 start, u64 end, int *page_started,
  744. unsigned long *nr_written,
  745. int unlock)
  746. {
  747. u64 alloc_hint = 0;
  748. u64 num_bytes;
  749. unsigned long ram_size;
  750. u64 disk_num_bytes;
  751. u64 cur_alloc_size;
  752. u64 blocksize = root->sectorsize;
  753. struct btrfs_key ins;
  754. struct extent_map *em;
  755. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  756. int ret = 0;
  757. BUG_ON(btrfs_is_free_space_inode(inode));
  758. num_bytes = (end - start + blocksize) & ~(blocksize - 1);
  759. num_bytes = max(blocksize, num_bytes);
  760. disk_num_bytes = num_bytes;
  761. /* if this is a small write inside eof, kick off defrag */
  762. if (num_bytes < 64 * 1024 &&
  763. (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
  764. btrfs_add_inode_defrag(trans, inode);
  765. if (start == 0) {
  766. /* lets try to make an inline extent */
  767. ret = cow_file_range_inline(trans, root, inode,
  768. start, end, 0, 0, NULL);
  769. if (ret == 0) {
  770. extent_clear_unlock_delalloc(inode,
  771. &BTRFS_I(inode)->io_tree,
  772. start, end, NULL,
  773. EXTENT_CLEAR_UNLOCK_PAGE |
  774. EXTENT_CLEAR_UNLOCK |
  775. EXTENT_CLEAR_DELALLOC |
  776. EXTENT_CLEAR_DIRTY |
  777. EXTENT_SET_WRITEBACK |
  778. EXTENT_END_WRITEBACK);
  779. *nr_written = *nr_written +
  780. (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
  781. *page_started = 1;
  782. goto out;
  783. } else if (ret < 0) {
  784. btrfs_abort_transaction(trans, root, ret);
  785. goto out_unlock;
  786. }
  787. }
  788. BUG_ON(disk_num_bytes >
  789. btrfs_super_total_bytes(root->fs_info->super_copy));
  790. alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
  791. btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
  792. while (disk_num_bytes > 0) {
  793. unsigned long op;
  794. cur_alloc_size = disk_num_bytes;
  795. ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
  796. root->sectorsize, 0, alloc_hint,
  797. &ins, 1);
  798. if (ret < 0) {
  799. btrfs_abort_transaction(trans, root, ret);
  800. goto out_unlock;
  801. }
  802. em = alloc_extent_map();
  803. BUG_ON(!em); /* -ENOMEM */
  804. em->start = start;
  805. em->orig_start = em->start;
  806. ram_size = ins.offset;
  807. em->len = ins.offset;
  808. em->block_start = ins.objectid;
  809. em->block_len = ins.offset;
  810. em->orig_block_len = ins.offset;
  811. em->bdev = root->fs_info->fs_devices->latest_bdev;
  812. set_bit(EXTENT_FLAG_PINNED, &em->flags);
  813. em->generation = -1;
  814. while (1) {
  815. write_lock(&em_tree->lock);
  816. ret = add_extent_mapping(em_tree, em);
  817. if (!ret)
  818. list_move(&em->list,
  819. &em_tree->modified_extents);
  820. write_unlock(&em_tree->lock);
  821. if (ret != -EEXIST) {
  822. free_extent_map(em);
  823. break;
  824. }
  825. btrfs_drop_extent_cache(inode, start,
  826. start + ram_size - 1, 0);
  827. }
  828. cur_alloc_size = ins.offset;
  829. ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
  830. ram_size, cur_alloc_size, 0);
  831. BUG_ON(ret); /* -ENOMEM */
  832. if (root->root_key.objectid ==
  833. BTRFS_DATA_RELOC_TREE_OBJECTID) {
  834. ret = btrfs_reloc_clone_csums(inode, start,
  835. cur_alloc_size);
  836. if (ret) {
  837. btrfs_abort_transaction(trans, root, ret);
  838. goto out_unlock;
  839. }
  840. }
  841. if (disk_num_bytes < cur_alloc_size)
  842. break;
  843. /* we're not doing compressed IO, don't unlock the first
  844. * page (which the caller expects to stay locked), don't
  845. * clear any dirty bits and don't set any writeback bits
  846. *
  847. * Do set the Private2 bit so we know this page was properly
  848. * setup for writepage
  849. */
  850. op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
  851. op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
  852. EXTENT_SET_PRIVATE2;
  853. extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
  854. start, start + ram_size - 1,
  855. locked_page, op);
  856. disk_num_bytes -= cur_alloc_size;
  857. num_bytes -= cur_alloc_size;
  858. alloc_hint = ins.objectid + ins.offset;
  859. start += cur_alloc_size;
  860. }
  861. out:
  862. return ret;
  863. out_unlock:
  864. extent_clear_unlock_delalloc(inode,
  865. &BTRFS_I(inode)->io_tree,
  866. start, end, locked_page,
  867. EXTENT_CLEAR_UNLOCK_PAGE |
  868. EXTENT_CLEAR_UNLOCK |
  869. EXTENT_CLEAR_DELALLOC |
  870. EXTENT_CLEAR_DIRTY |
  871. EXTENT_SET_WRITEBACK |
  872. EXTENT_END_WRITEBACK);
  873. goto out;
  874. }
  875. static noinline int cow_file_range(struct inode *inode,
  876. struct page *locked_page,
  877. u64 start, u64 end, int *page_started,
  878. unsigned long *nr_written,
  879. int unlock)
  880. {
  881. struct btrfs_trans_handle *trans;
  882. struct btrfs_root *root = BTRFS_I(inode)->root;
  883. int ret;
  884. trans = btrfs_join_transaction(root);
  885. if (IS_ERR(trans)) {
  886. extent_clear_unlock_delalloc(inode,
  887. &BTRFS_I(inode)->io_tree,
  888. start, end, locked_page,
  889. EXTENT_CLEAR_UNLOCK_PAGE |
  890. EXTENT_CLEAR_UNLOCK |
  891. EXTENT_CLEAR_DELALLOC |
  892. EXTENT_CLEAR_DIRTY |
  893. EXTENT_SET_WRITEBACK |
  894. EXTENT_END_WRITEBACK);
  895. return PTR_ERR(trans);
  896. }
  897. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  898. ret = __cow_file_range(trans, inode, root, locked_page, start, end,
  899. page_started, nr_written, unlock);
  900. btrfs_end_transaction(trans, root);
  901. return ret;
  902. }
  903. /*
  904. * work queue call back to started compression on a file and pages
  905. */
  906. static noinline void async_cow_start(struct btrfs_work *work)
  907. {
  908. struct async_cow *async_cow;
  909. int num_added = 0;
  910. async_cow = container_of(work, struct async_cow, work);
  911. compress_file_range(async_cow->inode, async_cow->locked_page,
  912. async_cow->start, async_cow->end, async_cow,
  913. &num_added);
  914. if (num_added == 0) {
  915. btrfs_add_delayed_iput(async_cow->inode);
  916. async_cow->inode = NULL;
  917. }
  918. }
  919. /*
  920. * work queue call back to submit previously compressed pages
  921. */
  922. static noinline void async_cow_submit(struct btrfs_work *work)
  923. {
  924. struct async_cow *async_cow;
  925. struct btrfs_root *root;
  926. unsigned long nr_pages;
  927. async_cow = container_of(work, struct async_cow, work);
  928. root = async_cow->root;
  929. nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
  930. PAGE_CACHE_SHIFT;
  931. if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
  932. 5 * 1024 * 1024 &&
  933. waitqueue_active(&root->fs_info->async_submit_wait))
  934. wake_up(&root->fs_info->async_submit_wait);
  935. if (async_cow->inode)
  936. submit_compressed_extents(async_cow->inode, async_cow);
  937. }
  938. static noinline void async_cow_free(struct btrfs_work *work)
  939. {
  940. struct async_cow *async_cow;
  941. async_cow = container_of(work, struct async_cow, work);
  942. if (async_cow->inode)
  943. btrfs_add_delayed_iput(async_cow->inode);
  944. kfree(async_cow);
  945. }
  946. static int cow_file_range_async(struct inode *inode, struct page *locked_page,
  947. u64 start, u64 end, int *page_started,
  948. unsigned long *nr_written)
  949. {
  950. struct async_cow *async_cow;
  951. struct btrfs_root *root = BTRFS_I(inode)->root;
  952. unsigned long nr_pages;
  953. u64 cur_end;
  954. int limit = 10 * 1024 * 1024;
  955. clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
  956. 1, 0, NULL, GFP_NOFS);
  957. while (start < end) {
  958. async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
  959. BUG_ON(!async_cow); /* -ENOMEM */
  960. async_cow->inode = igrab(inode);
  961. async_cow->root = root;
  962. async_cow->locked_page = locked_page;
  963. async_cow->start = start;
  964. if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
  965. cur_end = end;
  966. else
  967. cur_end = min(end, start + 512 * 1024 - 1);
  968. async_cow->end = cur_end;
  969. INIT_LIST_HEAD(&async_cow->extents);
  970. async_cow->work.func = async_cow_start;
  971. async_cow->work.ordered_func = async_cow_submit;
  972. async_cow->work.ordered_free = async_cow_free;
  973. async_cow->work.flags = 0;
  974. nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
  975. PAGE_CACHE_SHIFT;
  976. atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
  977. btrfs_queue_worker(&root->fs_info->delalloc_workers,
  978. &async_cow->work);
  979. if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
  980. wait_event(root->fs_info->async_submit_wait,
  981. (atomic_read(&root->fs_info->async_delalloc_pages) <
  982. limit));
  983. }
  984. while (atomic_read(&root->fs_info->async_submit_draining) &&
  985. atomic_read(&root->fs_info->async_delalloc_pages)) {
  986. wait_event(root->fs_info->async_submit_wait,
  987. (atomic_read(&root->fs_info->async_delalloc_pages) ==
  988. 0));
  989. }
  990. *nr_written += nr_pages;
  991. start = cur_end + 1;
  992. }
  993. *page_started = 1;
  994. return 0;
  995. }
  996. static noinline int csum_exist_in_range(struct btrfs_root *root,
  997. u64 bytenr, u64 num_bytes)
  998. {
  999. int ret;
  1000. struct btrfs_ordered_sum *sums;
  1001. LIST_HEAD(list);
  1002. ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
  1003. bytenr + num_bytes - 1, &list, 0);
  1004. if (ret == 0 && list_empty(&list))
  1005. return 0;
  1006. while (!list_empty(&list)) {
  1007. sums = list_entry(list.next, struct btrfs_ordered_sum, list);
  1008. list_del(&sums->list);
  1009. kfree(sums);
  1010. }
  1011. return 1;
  1012. }
  1013. /*
  1014. * when nowcow writeback call back. This checks for snapshots or COW copies
  1015. * of the extents that exist in the file, and COWs the file as required.
  1016. *
  1017. * If no cow copies or snapshots exist, we write directly to the existing
  1018. * blocks on disk
  1019. */
  1020. static noinline int run_delalloc_nocow(struct inode *inode,
  1021. struct page *locked_page,
  1022. u64 start, u64 end, int *page_started, int force,
  1023. unsigned long *nr_written)
  1024. {
  1025. struct btrfs_root *root = BTRFS_I(inode)->root;
  1026. struct btrfs_trans_handle *trans;
  1027. struct extent_buffer *leaf;
  1028. struct btrfs_path *path;
  1029. struct btrfs_file_extent_item *fi;
  1030. struct btrfs_key found_key;
  1031. u64 cow_start;
  1032. u64 cur_offset;
  1033. u64 extent_end;
  1034. u64 extent_offset;
  1035. u64 disk_bytenr;
  1036. u64 num_bytes;
  1037. u64 disk_num_bytes;
  1038. int extent_type;
  1039. int ret, err;
  1040. int type;
  1041. int nocow;
  1042. int check_prev = 1;
  1043. bool nolock;
  1044. u64 ino = btrfs_ino(inode);
  1045. path = btrfs_alloc_path();
  1046. if (!path) {
  1047. extent_clear_unlock_delalloc(inode,
  1048. &BTRFS_I(inode)->io_tree,
  1049. start, end, locked_page,
  1050. EXTENT_CLEAR_UNLOCK_PAGE |
  1051. EXTENT_CLEAR_UNLOCK |
  1052. EXTENT_CLEAR_DELALLOC |
  1053. EXTENT_CLEAR_DIRTY |
  1054. EXTENT_SET_WRITEBACK |
  1055. EXTENT_END_WRITEBACK);
  1056. return -ENOMEM;
  1057. }
  1058. nolock = btrfs_is_free_space_inode(inode);
  1059. if (nolock)
  1060. trans = btrfs_join_transaction_nolock(root);
  1061. else
  1062. trans = btrfs_join_transaction(root);
  1063. if (IS_ERR(trans)) {
  1064. extent_clear_unlock_delalloc(inode,
  1065. &BTRFS_I(inode)->io_tree,
  1066. start, end, locked_page,
  1067. EXTENT_CLEAR_UNLOCK_PAGE |
  1068. EXTENT_CLEAR_UNLOCK |
  1069. EXTENT_CLEAR_DELALLOC |
  1070. EXTENT_CLEAR_DIRTY |
  1071. EXTENT_SET_WRITEBACK |
  1072. EXTENT_END_WRITEBACK);
  1073. btrfs_free_path(path);
  1074. return PTR_ERR(trans);
  1075. }
  1076. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  1077. cow_start = (u64)-1;
  1078. cur_offset = start;
  1079. while (1) {
  1080. ret = btrfs_lookup_file_extent(trans, root, path, ino,
  1081. cur_offset, 0);
  1082. if (ret < 0) {
  1083. btrfs_abort_transaction(trans, root, ret);
  1084. goto error;
  1085. }
  1086. if (ret > 0 && path->slots[0] > 0 && check_prev) {
  1087. leaf = path->nodes[0];
  1088. btrfs_item_key_to_cpu(leaf, &found_key,
  1089. path->slots[0] - 1);
  1090. if (found_key.objectid == ino &&
  1091. found_key.type == BTRFS_EXTENT_DATA_KEY)
  1092. path->slots[0]--;
  1093. }
  1094. check_prev = 0;
  1095. next_slot:
  1096. leaf = path->nodes[0];
  1097. if (path->slots[0] >= btrfs_header_nritems(leaf)) {
  1098. ret = btrfs_next_leaf(root, path);
  1099. if (ret < 0) {
  1100. btrfs_abort_transaction(trans, root, ret);
  1101. goto error;
  1102. }
  1103. if (ret > 0)
  1104. break;
  1105. leaf = path->nodes[0];
  1106. }
  1107. nocow = 0;
  1108. disk_bytenr = 0;
  1109. num_bytes = 0;
  1110. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  1111. if (found_key.objectid > ino ||
  1112. found_key.type > BTRFS_EXTENT_DATA_KEY ||
  1113. found_key.offset > end)
  1114. break;
  1115. if (found_key.offset > cur_offset) {
  1116. extent_end = found_key.offset;
  1117. extent_type = 0;
  1118. goto out_check;
  1119. }
  1120. fi = btrfs_item_ptr(leaf, path->slots[0],
  1121. struct btrfs_file_extent_item);
  1122. extent_type = btrfs_file_extent_type(leaf, fi);
  1123. if (extent_type == BTRFS_FILE_EXTENT_REG ||
  1124. extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
  1125. disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
  1126. extent_offset = btrfs_file_extent_offset(leaf, fi);
  1127. extent_end = found_key.offset +
  1128. btrfs_file_extent_num_bytes(leaf, fi);
  1129. disk_num_bytes =
  1130. btrfs_file_extent_disk_num_bytes(leaf, fi);
  1131. if (extent_end <= start) {
  1132. path->slots[0]++;
  1133. goto next_slot;
  1134. }
  1135. if (disk_bytenr == 0)
  1136. goto out_check;
  1137. if (btrfs_file_extent_compression(leaf, fi) ||
  1138. btrfs_file_extent_encryption(leaf, fi) ||
  1139. btrfs_file_extent_other_encoding(leaf, fi))
  1140. goto out_check;
  1141. if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
  1142. goto out_check;
  1143. if (btrfs_extent_readonly(root, disk_bytenr))
  1144. goto out_check;
  1145. if (btrfs_cross_ref_exist(trans, root, ino,
  1146. found_key.offset -
  1147. extent_offset, disk_bytenr))
  1148. goto out_check;
  1149. disk_bytenr += extent_offset;
  1150. disk_bytenr += cur_offset - found_key.offset;
  1151. num_bytes = min(end + 1, extent_end) - cur_offset;
  1152. /*
  1153. * force cow if csum exists in the range.
  1154. * this ensure that csum for a given extent are
  1155. * either valid or do not exist.
  1156. */
  1157. if (csum_exist_in_range(root, disk_bytenr, num_bytes))
  1158. goto out_check;
  1159. nocow = 1;
  1160. } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
  1161. extent_end = found_key.offset +
  1162. btrfs_file_extent_inline_len(leaf, fi);
  1163. extent_end = ALIGN(extent_end, root->sectorsize);
  1164. } else {
  1165. BUG_ON(1);
  1166. }
  1167. out_check:
  1168. if (extent_end <= start) {
  1169. path->slots[0]++;
  1170. goto next_slot;
  1171. }
  1172. if (!nocow) {
  1173. if (cow_start == (u64)-1)
  1174. cow_start = cur_offset;
  1175. cur_offset = extent_end;
  1176. if (cur_offset > end)
  1177. break;
  1178. path->slots[0]++;
  1179. goto next_slot;
  1180. }
  1181. btrfs_release_path(path);
  1182. if (cow_start != (u64)-1) {
  1183. ret = __cow_file_range(trans, inode, root, locked_page,
  1184. cow_start, found_key.offset - 1,
  1185. page_started, nr_written, 1);
  1186. if (ret) {
  1187. btrfs_abort_transaction(trans, root, ret);
  1188. goto error;
  1189. }
  1190. cow_start = (u64)-1;
  1191. }
  1192. if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
  1193. struct extent_map *em;
  1194. struct extent_map_tree *em_tree;
  1195. em_tree = &BTRFS_I(inode)->extent_tree;
  1196. em = alloc_extent_map();
  1197. BUG_ON(!em); /* -ENOMEM */
  1198. em->start = cur_offset;
  1199. em->orig_start = found_key.offset - extent_offset;
  1200. em->len = num_bytes;
  1201. em->block_len = num_bytes;
  1202. em->block_start = disk_bytenr;
  1203. em->orig_block_len = disk_num_bytes;
  1204. em->bdev = root->fs_info->fs_devices->latest_bdev;
  1205. set_bit(EXTENT_FLAG_PINNED, &em->flags);
  1206. set_bit(EXTENT_FLAG_FILLING, &em->flags);
  1207. em->generation = -1;
  1208. while (1) {
  1209. write_lock(&em_tree->lock);
  1210. ret = add_extent_mapping(em_tree, em);
  1211. if (!ret)
  1212. list_move(&em->list,
  1213. &em_tree->modified_extents);
  1214. write_unlock(&em_tree->lock);
  1215. if (ret != -EEXIST) {
  1216. free_extent_map(em);
  1217. break;
  1218. }
  1219. btrfs_drop_extent_cache(inode, em->start,
  1220. em->start + em->len - 1, 0);
  1221. }
  1222. type = BTRFS_ORDERED_PREALLOC;
  1223. } else {
  1224. type = BTRFS_ORDERED_NOCOW;
  1225. }
  1226. ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
  1227. num_bytes, num_bytes, type);
  1228. BUG_ON(ret); /* -ENOMEM */
  1229. if (root->root_key.objectid ==
  1230. BTRFS_DATA_RELOC_TREE_OBJECTID) {
  1231. ret = btrfs_reloc_clone_csums(inode, cur_offset,
  1232. num_bytes);
  1233. if (ret) {
  1234. btrfs_abort_transaction(trans, root, ret);
  1235. goto error;
  1236. }
  1237. }
  1238. extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
  1239. cur_offset, cur_offset + num_bytes - 1,
  1240. locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
  1241. EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
  1242. EXTENT_SET_PRIVATE2);
  1243. cur_offset = extent_end;
  1244. if (cur_offset > end)
  1245. break;
  1246. }
  1247. btrfs_release_path(path);
  1248. if (cur_offset <= end && cow_start == (u64)-1) {
  1249. cow_start = cur_offset;
  1250. cur_offset = end;
  1251. }
  1252. if (cow_start != (u64)-1) {
  1253. ret = __cow_file_range(trans, inode, root, locked_page,
  1254. cow_start, end,
  1255. page_started, nr_written, 1);
  1256. if (ret) {
  1257. btrfs_abort_transaction(trans, root, ret);
  1258. goto error;
  1259. }
  1260. }
  1261. error:
  1262. err = btrfs_end_transaction(trans, root);
  1263. if (!ret)
  1264. ret = err;
  1265. if (ret && cur_offset < end)
  1266. extent_clear_unlock_delalloc(inode,
  1267. &BTRFS_I(inode)->io_tree,
  1268. cur_offset, end, locked_page,
  1269. EXTENT_CLEAR_UNLOCK_PAGE |
  1270. EXTENT_CLEAR_UNLOCK |
  1271. EXTENT_CLEAR_DELALLOC |
  1272. EXTENT_CLEAR_DIRTY |
  1273. EXTENT_SET_WRITEBACK |
  1274. EXTENT_END_WRITEBACK);
  1275. btrfs_free_path(path);
  1276. return ret;
  1277. }
  1278. /*
  1279. * extent_io.c call back to do delayed allocation processing
  1280. */
  1281. static int run_delalloc_range(struct inode *inode, struct page *locked_page,
  1282. u64 start, u64 end, int *page_started,
  1283. unsigned long *nr_written)
  1284. {
  1285. int ret;
  1286. struct btrfs_root *root = BTRFS_I(inode)->root;
  1287. if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
  1288. ret = run_delalloc_nocow(inode, locked_page, start, end,
  1289. page_started, 1, nr_written);
  1290. } else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
  1291. ret = run_delalloc_nocow(inode, locked_page, start, end,
  1292. page_started, 0, nr_written);
  1293. } else if (!btrfs_test_opt(root, COMPRESS) &&
  1294. !(BTRFS_I(inode)->force_compress) &&
  1295. !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
  1296. ret = cow_file_range(inode, locked_page, start, end,
  1297. page_started, nr_written, 1);
  1298. } else {
  1299. set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
  1300. &BTRFS_I(inode)->runtime_flags);
  1301. ret = cow_file_range_async(inode, locked_page, start, end,
  1302. page_started, nr_written);
  1303. }
  1304. return ret;
  1305. }
  1306. static void btrfs_split_extent_hook(struct inode *inode,
  1307. struct extent_state *orig, u64 split)
  1308. {
  1309. /* not delalloc, ignore it */
  1310. if (!(orig->state & EXTENT_DELALLOC))
  1311. return;
  1312. spin_lock(&BTRFS_I(inode)->lock);
  1313. BTRFS_I(inode)->outstanding_extents++;
  1314. spin_unlock(&BTRFS_I(inode)->lock);
  1315. }
  1316. /*
  1317. * extent_io.c merge_extent_hook, used to track merged delayed allocation
  1318. * extents so we can keep track of new extents that are just merged onto old
  1319. * extents, such as when we are doing sequential writes, so we can properly
  1320. * account for the metadata space we'll need.
  1321. */
  1322. static void btrfs_merge_extent_hook(struct inode *inode,
  1323. struct extent_state *new,
  1324. struct extent_state *other)
  1325. {
  1326. /* not delalloc, ignore it */
  1327. if (!(other->state & EXTENT_DELALLOC))
  1328. return;
  1329. spin_lock(&BTRFS_I(inode)->lock);
  1330. BTRFS_I(inode)->outstanding_extents--;
  1331. spin_unlock(&BTRFS_I(inode)->lock);
  1332. }
  1333. /*
  1334. * extent_io.c set_bit_hook, used to track delayed allocation
  1335. * bytes in this file, and to maintain the list of inodes that
  1336. * have pending delalloc work to be done.
  1337. */
  1338. static void btrfs_set_bit_hook(struct inode *inode,
  1339. struct extent_state *state, int *bits)
  1340. {
  1341. /*
  1342. * set_bit and clear bit hooks normally require _irqsave/restore
  1343. * but in this case, we are only testing for the DELALLOC
  1344. * bit, which is only set or cleared with irqs on
  1345. */
  1346. if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
  1347. struct btrfs_root *root = BTRFS_I(inode)->root;
  1348. u64 len = state->end + 1 - state->start;
  1349. bool do_list = !btrfs_is_free_space_inode(inode);
  1350. if (*bits & EXTENT_FIRST_DELALLOC) {
  1351. *bits &= ~EXTENT_FIRST_DELALLOC;
  1352. } else {
  1353. spin_lock(&BTRFS_I(inode)->lock);
  1354. BTRFS_I(inode)->outstanding_extents++;
  1355. spin_unlock(&BTRFS_I(inode)->lock);
  1356. }
  1357. spin_lock(&root->fs_info->delalloc_lock);
  1358. BTRFS_I(inode)->delalloc_bytes += len;
  1359. root->fs_info->delalloc_bytes += len;
  1360. if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
  1361. list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
  1362. &root->fs_info->delalloc_inodes);
  1363. }
  1364. spin_unlock(&root->fs_info->delalloc_lock);
  1365. }
  1366. }
  1367. /*
  1368. * extent_io.c clear_bit_hook, see set_bit_hook for why
  1369. */
  1370. static void btrfs_clear_bit_hook(struct inode *inode,
  1371. struct extent_state *state, int *bits)
  1372. {
  1373. /*
  1374. * set_bit and clear bit hooks normally require _irqsave/restore
  1375. * but in this case, we are only testing for the DELALLOC
  1376. * bit, which is only set or cleared with irqs on
  1377. */
  1378. if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
  1379. struct btrfs_root *root = BTRFS_I(inode)->root;
  1380. u64 len = state->end + 1 - state->start;
  1381. bool do_list = !btrfs_is_free_space_inode(inode);
  1382. if (*bits & EXTENT_FIRST_DELALLOC) {
  1383. *bits &= ~EXTENT_FIRST_DELALLOC;
  1384. } else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
  1385. spin_lock(&BTRFS_I(inode)->lock);
  1386. BTRFS_I(inode)->outstanding_extents--;
  1387. spin_unlock(&BTRFS_I(inode)->lock);
  1388. }
  1389. if (*bits & EXTENT_DO_ACCOUNTING)
  1390. btrfs_delalloc_release_metadata(inode, len);
  1391. if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
  1392. && do_list)
  1393. btrfs_free_reserved_data_space(inode, len);
  1394. spin_lock(&root->fs_info->delalloc_lock);
  1395. root->fs_info->delalloc_bytes -= len;
  1396. BTRFS_I(inode)->delalloc_bytes -= len;
  1397. if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
  1398. !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
  1399. list_del_init(&BTRFS_I(inode)->delalloc_inodes);
  1400. }
  1401. spin_unlock(&root->fs_info->delalloc_lock);
  1402. }
  1403. }
  1404. /*
  1405. * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
  1406. * we don't create bios that span stripes or chunks
  1407. */
  1408. int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
  1409. size_t size, struct bio *bio,
  1410. unsigned long bio_flags)
  1411. {
  1412. struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
  1413. u64 logical = (u64)bio->bi_sector << 9;
  1414. u64 length = 0;
  1415. u64 map_length;
  1416. int ret;
  1417. if (bio_flags & EXTENT_BIO_COMPRESSED)
  1418. return 0;
  1419. length = bio->bi_size;
  1420. map_length = length;
  1421. ret = btrfs_map_block(root->fs_info, READ, logical,
  1422. &map_length, NULL, 0);
  1423. /* Will always return 0 with map_multi == NULL */
  1424. BUG_ON(ret < 0);
  1425. if (map_length < length + size)
  1426. return 1;
  1427. return 0;
  1428. }
  1429. /*
  1430. * in order to insert checksums into the metadata in large chunks,
  1431. * we wait until bio submission time. All the pages in the bio are
  1432. * checksummed and sums are attached onto the ordered extent record.
  1433. *
  1434. * At IO completion time the cums attached on the ordered extent record
  1435. * are inserted into the btree
  1436. */
  1437. static int __btrfs_submit_bio_start(struct inode *inode, int rw,
  1438. struct bio *bio, int mirror_num,
  1439. unsigned long bio_flags,
  1440. u64 bio_offset)
  1441. {
  1442. struct btrfs_root *root = BTRFS_I(inode)->root;
  1443. int ret = 0;
  1444. ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
  1445. BUG_ON(ret); /* -ENOMEM */
  1446. return 0;
  1447. }
  1448. /*
  1449. * in order to insert checksums into the metadata in large chunks,
  1450. * we wait until bio submission time. All the pages in the bio are
  1451. * checksummed and sums are attached onto the ordered extent record.
  1452. *
  1453. * At IO completion time the cums attached on the ordered extent record
  1454. * are inserted into the btree
  1455. */
  1456. static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
  1457. int mirror_num, unsigned long bio_flags,
  1458. u64 bio_offset)
  1459. {
  1460. struct btrfs_root *root = BTRFS_I(inode)->root;
  1461. int ret;
  1462. ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
  1463. if (ret)
  1464. bio_endio(bio, ret);
  1465. return ret;
  1466. }
  1467. /*
  1468. * extent_io.c submission hook. This does the right thing for csum calculation
  1469. * on write, or reading the csums from the tree before a read
  1470. */
  1471. static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
  1472. int mirror_num, unsigned long bio_flags,
  1473. u64 bio_offset)
  1474. {
  1475. struct btrfs_root *root = BTRFS_I(inode)->root;
  1476. int ret = 0;
  1477. int skip_sum;
  1478. int metadata = 0;
  1479. int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
  1480. skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
  1481. if (btrfs_is_free_space_inode(inode))
  1482. metadata = 2;
  1483. if (!(rw & REQ_WRITE)) {
  1484. ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
  1485. if (ret)
  1486. goto out;
  1487. if (bio_flags & EXTENT_BIO_COMPRESSED) {
  1488. ret = btrfs_submit_compressed_read(inode, bio,
  1489. mirror_num,
  1490. bio_flags);
  1491. goto out;
  1492. } else if (!skip_sum) {
  1493. ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
  1494. if (ret)
  1495. goto out;
  1496. }
  1497. goto mapit;
  1498. } else if (async && !skip_sum) {
  1499. /* csum items have already been cloned */
  1500. if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
  1501. goto mapit;
  1502. /* we're doing a write, do the async checksumming */
  1503. ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
  1504. inode, rw, bio, mirror_num,
  1505. bio_flags, bio_offset,
  1506. __btrfs_submit_bio_start,
  1507. __btrfs_submit_bio_done);
  1508. goto out;
  1509. } else if (!skip_sum) {
  1510. ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
  1511. if (ret)
  1512. goto out;
  1513. }
  1514. mapit:
  1515. ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
  1516. out:
  1517. if (ret < 0)
  1518. bio_endio(bio, ret);
  1519. return ret;
  1520. }
  1521. /*
  1522. * given a list of ordered sums record them in the inode. This happens
  1523. * at IO completion time based on sums calculated at bio submission time.
  1524. */
  1525. static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
  1526. struct inode *inode, u64 file_offset,
  1527. struct list_head *list)
  1528. {
  1529. struct btrfs_ordered_sum *sum;
  1530. list_for_each_entry(sum, list, list) {
  1531. btrfs_csum_file_blocks(trans,
  1532. BTRFS_I(inode)->root->fs_info->csum_root, sum);
  1533. }
  1534. return 0;
  1535. }
  1536. int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
  1537. struct extent_state **cached_state)
  1538. {
  1539. WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
  1540. return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
  1541. cached_state, GFP_NOFS);
  1542. }
  1543. /* see btrfs_writepage_start_hook for details on why this is required */
  1544. struct btrfs_writepage_fixup {
  1545. struct page *page;
  1546. struct btrfs_work work;
  1547. };
  1548. static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
  1549. {
  1550. struct btrfs_writepage_fixup *fixup;
  1551. struct btrfs_ordered_extent *ordered;
  1552. struct extent_state *cached_state = NULL;
  1553. struct page *page;
  1554. struct inode *inode;
  1555. u64 page_start;
  1556. u64 page_end;
  1557. int ret;
  1558. fixup = container_of(work, struct btrfs_writepage_fixup, work);
  1559. page = fixup->page;
  1560. again:
  1561. lock_page(page);
  1562. if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
  1563. ClearPageChecked(page);
  1564. goto out_page;
  1565. }
  1566. inode = page->mapping->host;
  1567. page_start = page_offset(page);
  1568. page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;
  1569. lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
  1570. &cached_state);
  1571. /* already ordered? We're done */
  1572. if (PagePrivate2(page))
  1573. goto out;
  1574. ordered = btrfs_lookup_ordered_extent(inode, page_start);
  1575. if (ordered) {
  1576. unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
  1577. page_end, &cached_state, GFP_NOFS);
  1578. unlock_page(page);
  1579. btrfs_start_ordered_extent(inode, ordered, 1);
  1580. btrfs_put_ordered_extent(ordered);
  1581. goto again;
  1582. }
  1583. ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
  1584. if (ret) {
  1585. mapping_set_error(page->mapping, ret);
  1586. end_extent_writepage(page, ret, page_start, page_end);
  1587. ClearPageChecked(page);
  1588. goto out;
  1589. }
  1590. btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
  1591. ClearPageChecked(page);
  1592. set_page_dirty(page);
  1593. out:
  1594. unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
  1595. &cached_state, GFP_NOFS);
  1596. out_page:
  1597. unlock_page(page);
  1598. page_cache_release(page);
  1599. kfree(fixup);
  1600. }
  1601. /*
  1602. * There are a few paths in the higher layers of the kernel that directly
  1603. * set the page dirty bit without asking the filesystem if it is a
  1604. * good idea. This causes problems because we want to make sure COW
  1605. * properly happens and the data=ordered rules are followed.
  1606. *
  1607. * In our case any range that doesn't have the ORDERED bit set
  1608. * hasn't been properly setup for IO. We kick off an async process
  1609. * to fix it up. The async helper will wait for ordered extents, set
  1610. * the delalloc bit and make it safe to write the page.
  1611. */
  1612. static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
  1613. {
  1614. struct inode *inode = page->mapping->host;
  1615. struct btrfs_writepage_fixup *fixup;
  1616. struct btrfs_root *root = BTRFS_I(inode)->root;
  1617. /* this page is properly in the ordered list */
  1618. if (TestClearPagePrivate2(page))
  1619. return 0;
  1620. if (PageChecked(page))
  1621. return -EAGAIN;
  1622. fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
  1623. if (!fixup)
  1624. return -EAGAIN;
  1625. SetPageChecked(page);
  1626. page_cache_get(page);
  1627. fixup->work.func = btrfs_writepage_fixup_worker;
  1628. fixup->page = page;
  1629. btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
  1630. return -EBUSY;
  1631. }
  1632. static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
  1633. struct inode *inode, u64 file_pos,
  1634. u64 disk_bytenr, u64 disk_num_bytes,
  1635. u64 num_bytes, u64 ram_bytes,
  1636. u8 compression, u8 encryption,
  1637. u16 other_encoding, int extent_type)
  1638. {
  1639. struct btrfs_root *root = BTRFS_I(inode)->root;
  1640. struct btrfs_file_extent_item *fi;
  1641. struct btrfs_path *path;
  1642. struct extent_buffer *leaf;
  1643. struct btrfs_key ins;
  1644. int ret;
  1645. path = btrfs_alloc_path();
  1646. if (!path)
  1647. return -ENOMEM;
  1648. path->leave_spinning = 1;
  1649. /*
  1650. * we may be replacing one extent in the tree with another.
  1651. * The new extent is pinned in the extent map, and we don't want
  1652. * to drop it from the cache until it is completely in the btree.
  1653. *
  1654. * So, tell btrfs_drop_extents to leave this extent in the cache.
  1655. * the caller is expected to unpin it and allow it to be merged
  1656. * with the others.
  1657. */
  1658. ret = btrfs_drop_extents(trans, root, inode, file_pos,
  1659. file_pos + num_bytes, 0);
  1660. if (ret)
  1661. goto out;
  1662. ins.objectid = btrfs_ino(inode);
  1663. ins.offset = file_pos;
  1664. ins.type = BTRFS_EXTENT_DATA_KEY;
  1665. ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
  1666. if (ret)
  1667. goto out;
  1668. leaf = path->nodes[0];
  1669. fi = btrfs_item_ptr(leaf, path->slots[0],
  1670. struct btrfs_file_extent_item);
  1671. btrfs_set_file_extent_generation(leaf, fi, trans->transid);
  1672. btrfs_set_file_extent_type(leaf, fi, extent_type);
  1673. btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
  1674. btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
  1675. btrfs_set_file_extent_offset(leaf, fi, 0);
  1676. btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
  1677. btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
  1678. btrfs_set_file_extent_compression(leaf, fi, compression);
  1679. btrfs_set_file_extent_encryption(leaf, fi, encryption);
  1680. btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
  1681. btrfs_mark_buffer_dirty(leaf);
  1682. btrfs_release_path(path);
  1683. inode_add_bytes(inode, num_bytes);
  1684. ins.objectid = disk_bytenr;
  1685. ins.offset = disk_num_bytes;
  1686. ins.type = BTRFS_EXTENT_ITEM_KEY;
  1687. ret = btrfs_alloc_reserved_file_extent(trans, root,
  1688. root->root_key.objectid,
  1689. btrfs_ino(inode), file_pos, &ins);
  1690. out:
  1691. btrfs_free_path(path);
  1692. return ret;
  1693. }
  1694. /*
  1695. * helper function for btrfs_finish_ordered_io, this
  1696. * just reads in some of the csum leaves to prime them into ram
  1697. * before we start the transaction. It limits the amount of btree
  1698. * reads required while inside the transaction.
  1699. */
  1700. /* as ordered data IO finishes, this gets called so we can finish
  1701. * an ordered extent if the range of bytes in the file it covers are
  1702. * fully written.
  1703. */
  1704. static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
  1705. {
  1706. struct inode *inode = ordered_extent->inode;
  1707. struct btrfs_root *root = BTRFS_I(inode)->root;
  1708. struct btrfs_trans_handle *trans = NULL;
  1709. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  1710. struct extent_state *cached_state = NULL;
  1711. int compress_type = 0;
  1712. int ret;
  1713. bool nolock;
  1714. nolock = btrfs_is_free_space_inode(inode);
  1715. if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
  1716. ret = -EIO;
  1717. goto out;
  1718. }
  1719. if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
  1720. BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
  1721. btrfs_ordered_update_i_size(inode, 0, ordered_extent);
  1722. if (nolock)
  1723. trans = btrfs_join_transaction_nolock(root);
  1724. else
  1725. trans = btrfs_join_transaction(root);
  1726. if (IS_ERR(trans)) {
  1727. ret = PTR_ERR(trans);
  1728. trans = NULL;
  1729. goto out;
  1730. }
  1731. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  1732. ret = btrfs_update_inode_fallback(trans, root, inode);
  1733. if (ret) /* -ENOMEM or corruption */
  1734. btrfs_abort_transaction(trans, root, ret);
  1735. goto out;
  1736. }
  1737. lock_extent_bits(io_tree, ordered_extent->file_offset,
  1738. ordered_extent->file_offset + ordered_extent->len - 1,
  1739. 0, &cached_state);
  1740. if (nolock)
  1741. trans = btrfs_join_transaction_nolock(root);
  1742. else
  1743. trans = btrfs_join_transaction(root);
  1744. if (IS_ERR(trans)) {
  1745. ret = PTR_ERR(trans);
  1746. trans = NULL;
  1747. goto out_unlock;
  1748. }
  1749. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  1750. if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
  1751. compress_type = ordered_extent->compress_type;
  1752. if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
  1753. BUG_ON(compress_type);
  1754. ret = btrfs_mark_extent_written(trans, inode,
  1755. ordered_extent->file_offset,
  1756. ordered_extent->file_offset +
  1757. ordered_extent->len);
  1758. } else {
  1759. BUG_ON(root == root->fs_info->tree_root);
  1760. ret = insert_reserved_file_extent(trans, inode,
  1761. ordered_extent->file_offset,
  1762. ordered_extent->start,
  1763. ordered_extent->disk_len,
  1764. ordered_extent->len,
  1765. ordered_extent->len,
  1766. compress_type, 0, 0,
  1767. BTRFS_FILE_EXTENT_REG);
  1768. }
  1769. unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
  1770. ordered_extent->file_offset, ordered_extent->len,
  1771. trans->transid);
  1772. if (ret < 0) {
  1773. btrfs_abort_transaction(trans, root, ret);
  1774. goto out_unlock;
  1775. }
  1776. add_pending_csums(trans, inode, ordered_extent->file_offset,
  1777. &ordered_extent->list);
  1778. btrfs_ordered_update_i_size(inode, 0, ordered_extent);
  1779. ret = btrfs_update_inode_fallback(trans, root, inode);
  1780. if (ret) { /* -ENOMEM or corruption */
  1781. btrfs_abort_transaction(trans, root, ret);
  1782. goto out_unlock;
  1783. }
  1784. ret = 0;
  1785. out_unlock:
  1786. unlock_extent_cached(io_tree, ordered_extent->file_offset,
  1787. ordered_extent->file_offset +
  1788. ordered_extent->len - 1, &cached_state, GFP_NOFS);
  1789. out:
  1790. if (root != root->fs_info->tree_root)
  1791. btrfs_delalloc_release_metadata(inode, ordered_extent->len);
  1792. if (trans)
  1793. btrfs_end_transaction(trans, root);
  1794. if (ret)
  1795. clear_extent_uptodate(io_tree, ordered_extent->file_offset,
  1796. ordered_extent->file_offset +
  1797. ordered_extent->len - 1, NULL, GFP_NOFS);
  1798. /*
  1799. * This needs to be done to make sure anybody waiting knows we are done
  1800. * updating everything for this ordered extent.
  1801. */
  1802. btrfs_remove_ordered_extent(inode, ordered_extent);
  1803. /* once for us */
  1804. btrfs_put_ordered_extent(ordered_extent);
  1805. /* once for the tree */
  1806. btrfs_put_ordered_extent(ordered_extent);
  1807. return ret;
  1808. }
  1809. static void finish_ordered_fn(struct btrfs_work *work)
  1810. {
  1811. struct btrfs_ordered_extent *ordered_extent;
  1812. ordered_extent = container_of(work, struct btrfs_ordered_extent, work);
  1813. btrfs_finish_ordered_io(ordered_extent);
  1814. }
  1815. static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
  1816. struct extent_state *state, int uptodate)
  1817. {
  1818. struct inode *inode = page->mapping->host;
  1819. struct btrfs_root *root = BTRFS_I(inode)->root;
  1820. struct btrfs_ordered_extent *ordered_extent = NULL;
  1821. struct btrfs_workers *workers;
  1822. trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
  1823. ClearPagePrivate2(page);
  1824. if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
  1825. end - start + 1, uptodate))
  1826. return 0;
  1827. ordered_extent->work.func = finish_ordered_fn;
  1828. ordered_extent->work.flags = 0;
  1829. if (btrfs_is_free_space_inode(inode))
  1830. workers = &root->fs_info->endio_freespace_worker;
  1831. else
  1832. workers = &root->fs_info->endio_write_workers;
  1833. btrfs_queue_worker(workers, &ordered_extent->work);
  1834. return 0;
  1835. }
  1836. /*
  1837. * when reads are done, we need to check csums to verify the data is correct
  1838. * if there's a match, we allow the bio to finish. If not, the code in
  1839. * extent_io.c will try to find good copies for us.
  1840. */
  1841. static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
  1842. struct extent_state *state, int mirror)
  1843. {
  1844. size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
  1845. struct inode *inode = page->mapping->host;
  1846. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  1847. char *kaddr;
  1848. u64 private = ~(u32)0;
  1849. int ret;
  1850. struct btrfs_root *root = BTRFS_I(inode)->root;
  1851. u32 csum = ~(u32)0;
  1852. if (PageChecked(page)) {
  1853. ClearPageChecked(page);
  1854. goto good;
  1855. }
  1856. if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
  1857. goto good;
  1858. if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
  1859. test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
  1860. clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
  1861. GFP_NOFS);
  1862. return 0;
  1863. }
  1864. if (state && state->start == start) {
  1865. private = state->private;
  1866. ret = 0;
  1867. } else {
  1868. ret = get_state_private(io_tree, start, &private);
  1869. }
  1870. kaddr = kmap_atomic(page);
  1871. if (ret)
  1872. goto zeroit;
  1873. csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
  1874. btrfs_csum_final(csum, (char *)&csum);
  1875. if (csum != private)
  1876. goto zeroit;
  1877. kunmap_atomic(kaddr);
  1878. good:
  1879. return 0;
  1880. zeroit:
  1881. printk_ratelimited(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
  1882. "private %llu\n",
  1883. (unsigned long long)btrfs_ino(page->mapping->host),
  1884. (unsigned long long)start, csum,
  1885. (unsigned long long)private);
  1886. memset(kaddr + offset, 1, end - start + 1);
  1887. flush_dcache_page(page);
  1888. kunmap_atomic(kaddr);
  1889. if (private == 0)
  1890. return 0;
  1891. return -EIO;
  1892. }
  1893. struct delayed_iput {
  1894. struct list_head list;
  1895. struct inode *inode;
  1896. };
  1897. /* JDM: If this is fs-wide, why can't we add a pointer to
  1898. * btrfs_inode instead and avoid the allocation? */
  1899. void btrfs_add_delayed_iput(struct inode *inode)
  1900. {
  1901. struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
  1902. struct delayed_iput *delayed;
  1903. if (atomic_add_unless(&inode->i_count, -1, 1))
  1904. return;
  1905. delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
  1906. delayed->inode = inode;
  1907. spin_lock(&fs_info->delayed_iput_lock);
  1908. list_add_tail(&delayed->list, &fs_info->delayed_iputs);
  1909. spin_unlock(&fs_info->delayed_iput_lock);
  1910. }
  1911. void btrfs_run_delayed_iputs(struct btrfs_root *root)
  1912. {
  1913. LIST_HEAD(list);
  1914. struct btrfs_fs_info *fs_info = root->fs_info;
  1915. struct delayed_iput *delayed;
  1916. int empty;
  1917. spin_lock(&fs_info->delayed_iput_lock);
  1918. empty = list_empty(&fs_info->delayed_iputs);
  1919. spin_unlock(&fs_info->delayed_iput_lock);
  1920. if (empty)
  1921. return;
  1922. spin_lock(&fs_info->delayed_iput_lock);
  1923. list_splice_init(&fs_info->delayed_iputs, &list);
  1924. spin_unlock(&fs_info->delayed_iput_lock);
  1925. while (!list_empty(&list)) {
  1926. delayed = list_entry(list.next, struct delayed_iput, list);
  1927. list_del(&delayed->list);
  1928. iput(delayed->inode);
  1929. kfree(delayed);
  1930. }
  1931. }
  1932. enum btrfs_orphan_cleanup_state {
  1933. ORPHAN_CLEANUP_STARTED = 1,
  1934. ORPHAN_CLEANUP_DONE = 2,
  1935. };
  1936. /*
  1937. * This is called in transaction commit time. If there are no orphan
  1938. * files in the subvolume, it removes orphan item and frees block_rsv
  1939. * structure.
  1940. */
  1941. void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
  1942. struct btrfs_root *root)
  1943. {
  1944. struct btrfs_block_rsv *block_rsv;
  1945. int ret;
  1946. if (atomic_read(&root->orphan_inodes) ||
  1947. root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
  1948. return;
  1949. spin_lock(&root->orphan_lock);
  1950. if (atomic_read(&root->orphan_inodes)) {
  1951. spin_unlock(&root->orphan_lock);
  1952. return;
  1953. }
  1954. if (root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) {
  1955. spin_unlock(&root->orphan_lock);
  1956. return;
  1957. }
  1958. block_rsv = root->orphan_block_rsv;
  1959. root->orphan_block_rsv = NULL;
  1960. spin_unlock(&root->orphan_lock);
  1961. if (root->orphan_item_inserted &&
  1962. btrfs_root_refs(&root->root_item) > 0) {
  1963. ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
  1964. root->root_key.objectid);
  1965. BUG_ON(ret);
  1966. root->orphan_item_inserted = 0;
  1967. }
  1968. if (block_rsv) {
  1969. WARN_ON(block_rsv->size > 0);
  1970. btrfs_free_block_rsv(root, block_rsv);
  1971. }
  1972. }
  1973. /*
  1974. * This creates an orphan entry for the given inode in case something goes
  1975. * wrong in the middle of an unlink/truncate.
  1976. *
  1977. * NOTE: caller of this function should reserve 5 units of metadata for
  1978. * this function.
  1979. */
  1980. int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
  1981. {
  1982. struct btrfs_root *root = BTRFS_I(inode)->root;
  1983. struct btrfs_block_rsv *block_rsv = NULL;
  1984. int reserve = 0;
  1985. int insert = 0;
  1986. int ret;
  1987. if (!root->orphan_block_rsv) {
  1988. block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
  1989. if (!block_rsv)
  1990. return -ENOMEM;
  1991. }
  1992. spin_lock(&root->orphan_lock);
  1993. if (!root->orphan_block_rsv) {
  1994. root->orphan_block_rsv = block_rsv;
  1995. } else if (block_rsv) {
  1996. btrfs_free_block_rsv(root, block_rsv);
  1997. block_rsv = NULL;
  1998. }
  1999. if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  2000. &BTRFS_I(inode)->runtime_flags)) {
  2001. #if 0
  2002. /*
  2003. * For proper ENOSPC handling, we should do orphan
  2004. * cleanup when mounting. But this introduces backward
  2005. * compatibility issue.
  2006. */
  2007. if (!xchg(&root->orphan_item_inserted, 1))
  2008. insert = 2;
  2009. else
  2010. insert = 1;
  2011. #endif
  2012. insert = 1;
  2013. atomic_inc(&root->orphan_inodes);
  2014. }
  2015. if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
  2016. &BTRFS_I(inode)->runtime_flags))
  2017. reserve = 1;
  2018. spin_unlock(&root->orphan_lock);
  2019. /* grab metadata reservation from transaction handle */
  2020. if (reserve) {
  2021. ret = btrfs_orphan_reserve_metadata(trans, inode);
  2022. BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */
  2023. }
  2024. /* insert an orphan item to track this unlinked/truncated file */
  2025. if (insert >= 1) {
  2026. ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
  2027. if (ret && ret != -EEXIST) {
  2028. clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  2029. &BTRFS_I(inode)->runtime_flags);
  2030. btrfs_abort_transaction(trans, root, ret);
  2031. return ret;
  2032. }
  2033. ret = 0;
  2034. }
  2035. /* insert an orphan item to track subvolume contains orphan files */
  2036. if (insert >= 2) {
  2037. ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
  2038. root->root_key.objectid);
  2039. if (ret && ret != -EEXIST) {
  2040. btrfs_abort_transaction(trans, root, ret);
  2041. return ret;
  2042. }
  2043. }
  2044. return 0;
  2045. }
  2046. /*
  2047. * We have done the truncate/delete so we can go ahead and remove the orphan
  2048. * item for this particular inode.
  2049. */
  2050. int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
  2051. {
  2052. struct btrfs_root *root = BTRFS_I(inode)->root;
  2053. int delete_item = 0;
  2054. int release_rsv = 0;
  2055. int ret = 0;
  2056. spin_lock(&root->orphan_lock);
  2057. if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  2058. &BTRFS_I(inode)->runtime_flags))
  2059. delete_item = 1;
  2060. if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
  2061. &BTRFS_I(inode)->runtime_flags))
  2062. release_rsv = 1;
  2063. spin_unlock(&root->orphan_lock);
  2064. if (trans && delete_item) {
  2065. ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
  2066. BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
  2067. }
  2068. if (release_rsv) {
  2069. btrfs_orphan_release_metadata(inode);
  2070. atomic_dec(&root->orphan_inodes);
  2071. }
  2072. return 0;
  2073. }
  2074. /*
  2075. * this cleans up any orphans that may be left on the list from the last use
  2076. * of this root.
  2077. */
  2078. int btrfs_orphan_cleanup(struct btrfs_root *root)
  2079. {
  2080. struct btrfs_path *path;
  2081. struct extent_buffer *leaf;
  2082. struct btrfs_key key, found_key;
  2083. struct btrfs_trans_handle *trans;
  2084. struct inode *inode;
  2085. u64 last_objectid = 0;
  2086. int ret = 0, nr_unlink = 0, nr_truncate = 0;
  2087. if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
  2088. return 0;
  2089. path = btrfs_alloc_path();
  2090. if (!path) {
  2091. ret = -ENOMEM;
  2092. goto out;
  2093. }
  2094. path->reada = -1;
  2095. key.objectid = BTRFS_ORPHAN_OBJECTID;
  2096. btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
  2097. key.offset = (u64)-1;
  2098. while (1) {
  2099. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  2100. if (ret < 0)
  2101. goto out;
  2102. /*
  2103. * if ret == 0 means we found what we were searching for, which
  2104. * is weird, but possible, so only screw with path if we didn't
  2105. * find the key and see if we have stuff that matches
  2106. */
  2107. if (ret > 0) {
  2108. ret = 0;
  2109. if (path->slots[0] == 0)
  2110. break;
  2111. path->slots[0]--;
  2112. }
  2113. /* pull out the item */
  2114. leaf = path->nodes[0];
  2115. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  2116. /* make sure the item matches what we want */
  2117. if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
  2118. break;
  2119. if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
  2120. break;
  2121. /* release the path since we're done with it */
  2122. btrfs_release_path(path);
  2123. /*
  2124. * this is where we are basically btrfs_lookup, without the
  2125. * crossing root thing. we store the inode number in the
  2126. * offset of the orphan item.
  2127. */
  2128. if (found_key.offset == last_objectid) {
  2129. printk(KERN_ERR "btrfs: Error removing orphan entry, "
  2130. "stopping orphan cleanup\n");
  2131. ret = -EINVAL;
  2132. goto out;
  2133. }
  2134. last_objectid = found_key.offset;
  2135. found_key.objectid = found_key.offset;
  2136. found_key.type = BTRFS_INODE_ITEM_KEY;
  2137. found_key.offset = 0;
  2138. inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
  2139. ret = PTR_RET(inode);
  2140. if (ret && ret != -ESTALE)
  2141. goto out;
  2142. if (ret == -ESTALE && root == root->fs_info->tree_root) {
  2143. struct btrfs_root *dead_root;
  2144. struct btrfs_fs_info *fs_info = root->fs_info;
  2145. int is_dead_root = 0;
  2146. /*
  2147. * this is an orphan in the tree root. Currently these
  2148. * could come from 2 sources:
  2149. * a) a snapshot deletion in progress
  2150. * b) a free space cache inode
  2151. * We need to distinguish those two, as the snapshot
  2152. * orphan must not get deleted.
  2153. * find_dead_roots already ran before us, so if this
  2154. * is a snapshot deletion, we should find the root
  2155. * in the dead_roots list
  2156. */
  2157. spin_lock(&fs_info->trans_lock);
  2158. list_for_each_entry(dead_root, &fs_info->dead_roots,
  2159. root_list) {
  2160. if (dead_root->root_key.objectid ==
  2161. found_key.objectid) {
  2162. is_dead_root = 1;
  2163. break;
  2164. }
  2165. }
  2166. spin_unlock(&fs_info->trans_lock);
  2167. if (is_dead_root) {
  2168. /* prevent this orphan from being found again */
  2169. key.offset = found_key.objectid - 1;
  2170. continue;
  2171. }
  2172. }
  2173. /*
  2174. * Inode is already gone but the orphan item is still there,
  2175. * kill the orphan item.
  2176. */
  2177. if (ret == -ESTALE) {
  2178. trans = btrfs_start_transaction(root, 1);
  2179. if (IS_ERR(trans)) {
  2180. ret = PTR_ERR(trans);
  2181. goto out;
  2182. }
  2183. printk(KERN_ERR "auto deleting %Lu\n",
  2184. found_key.objectid);
  2185. ret = btrfs_del_orphan_item(trans, root,
  2186. found_key.objectid);
  2187. BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
  2188. btrfs_end_transaction(trans, root);
  2189. continue;
  2190. }
  2191. /*
  2192. * add this inode to the orphan list so btrfs_orphan_del does
  2193. * the proper thing when we hit it
  2194. */
  2195. set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  2196. &BTRFS_I(inode)->runtime_flags);
  2197. /* if we have links, this was a truncate, lets do that */
  2198. if (inode->i_nlink) {
  2199. if (!S_ISREG(inode->i_mode)) {
  2200. WARN_ON(1);
  2201. iput(inode);
  2202. continue;
  2203. }
  2204. nr_truncate++;
  2205. /* 1 for the orphan item deletion. */
  2206. trans = btrfs_start_transaction(root, 1);
  2207. if (IS_ERR(trans)) {
  2208. ret = PTR_ERR(trans);
  2209. goto out;
  2210. }
  2211. ret = btrfs_orphan_add(trans, inode);
  2212. btrfs_end_transaction(trans, root);
  2213. if (ret)
  2214. goto out;
  2215. ret = btrfs_truncate(inode);
  2216. } else {
  2217. nr_unlink++;
  2218. }
  2219. /* this will do delete_inode and everything for us */
  2220. iput(inode);
  2221. if (ret)
  2222. goto out;
  2223. }
  2224. /* release the path since we're done with it */
  2225. btrfs_release_path(path);
  2226. root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
  2227. if (root->orphan_block_rsv)
  2228. btrfs_block_rsv_release(root, root->orphan_block_rsv,
  2229. (u64)-1);
  2230. if (root->orphan_block_rsv || root->orphan_item_inserted) {
  2231. trans = btrfs_join_transaction(root);
  2232. if (!IS_ERR(trans))
  2233. btrfs_end_transaction(trans, root);
  2234. }
  2235. if (nr_unlink)
  2236. printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
  2237. if (nr_truncate)
  2238. printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
  2239. out:
  2240. if (ret)
  2241. printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
  2242. btrfs_free_path(path);
  2243. return ret;
  2244. }
  2245. /*
  2246. * very simple check to peek ahead in the leaf looking for xattrs. If we
  2247. * don't find any xattrs, we know there can't be any acls.
  2248. *
  2249. * slot is the slot the inode is in, objectid is the objectid of the inode
  2250. */
  2251. static noinline int acls_after_inode_item(struct extent_buffer *leaf,
  2252. int slot, u64 objectid)
  2253. {
  2254. u32 nritems = btrfs_header_nritems(leaf);
  2255. struct btrfs_key found_key;
  2256. int scanned = 0;
  2257. slot++;
  2258. while (slot < nritems) {
  2259. btrfs_item_key_to_cpu(leaf, &found_key, slot);
  2260. /* we found a different objectid, there must not be acls */
  2261. if (found_key.objectid != objectid)
  2262. return 0;
  2263. /* we found an xattr, assume we've got an acl */
  2264. if (found_key.type == BTRFS_XATTR_ITEM_KEY)
  2265. return 1;
  2266. /*
  2267. * we found a key greater than an xattr key, there can't
  2268. * be any acls later on
  2269. */
  2270. if (found_key.type > BTRFS_XATTR_ITEM_KEY)
  2271. return 0;
  2272. slot++;
  2273. scanned++;
  2274. /*
  2275. * it goes inode, inode backrefs, xattrs, extents,
  2276. * so if there are a ton of hard links to an inode there can
  2277. * be a lot of backrefs. Don't waste time searching too hard,
  2278. * this is just an optimization
  2279. */
  2280. if (scanned >= 8)
  2281. break;
  2282. }
  2283. /* we hit the end of the leaf before we found an xattr or
  2284. * something larger than an xattr. We have to assume the inode
  2285. * has acls
  2286. */
  2287. return 1;
  2288. }
  2289. /*
  2290. * read an inode from the btree into the in-memory inode
  2291. */
  2292. static void btrfs_read_locked_inode(struct inode *inode)
  2293. {
  2294. struct btrfs_path *path;
  2295. struct extent_buffer *leaf;
  2296. struct btrfs_inode_item *inode_item;
  2297. struct btrfs_timespec *tspec;
  2298. struct btrfs_root *root = BTRFS_I(inode)->root;
  2299. struct btrfs_key location;
  2300. int maybe_acls;
  2301. u32 rdev;
  2302. int ret;
  2303. bool filled = false;
  2304. ret = btrfs_fill_inode(inode, &rdev);
  2305. if (!ret)
  2306. filled = true;
  2307. path = btrfs_alloc_path();
  2308. if (!path)
  2309. goto make_bad;
  2310. path->leave_spinning = 1;
  2311. memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
  2312. ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
  2313. if (ret)
  2314. goto make_bad;
  2315. leaf = path->nodes[0];
  2316. if (filled)
  2317. goto cache_acl;
  2318. inode_item = btrfs_item_ptr(leaf, path->slots[0],
  2319. struct btrfs_inode_item);
  2320. inode->i_mode = btrfs_inode_mode(leaf, inode_item);
  2321. set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
  2322. i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
  2323. i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
  2324. btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
  2325. tspec = btrfs_inode_atime(inode_item);
  2326. inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  2327. inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  2328. tspec = btrfs_inode_mtime(inode_item);
  2329. inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  2330. inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  2331. tspec = btrfs_inode_ctime(inode_item);
  2332. inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
  2333. inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
  2334. inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
  2335. BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
  2336. BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);
  2337. /*
  2338. * If we were modified in the current generation and evicted from memory
  2339. * and then re-read we need to do a full sync since we don't have any
  2340. * idea about which extents were modified before we were evicted from
  2341. * cache.
  2342. */
  2343. if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
  2344. set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
  2345. &BTRFS_I(inode)->runtime_flags);
  2346. inode->i_version = btrfs_inode_sequence(leaf, inode_item);
  2347. inode->i_generation = BTRFS_I(inode)->generation;
  2348. inode->i_rdev = 0;
  2349. rdev = btrfs_inode_rdev(leaf, inode_item);
  2350. BTRFS_I(inode)->index_cnt = (u64)-1;
  2351. BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
  2352. cache_acl:
  2353. /*
  2354. * try to precache a NULL acl entry for files that don't have
  2355. * any xattrs or acls
  2356. */
  2357. maybe_acls = acls_after_inode_item(leaf, path->slots[0],
  2358. btrfs_ino(inode));
  2359. if (!maybe_acls)
  2360. cache_no_acl(inode);
  2361. btrfs_free_path(path);
  2362. switch (inode->i_mode & S_IFMT) {
  2363. case S_IFREG:
  2364. inode->i_mapping->a_ops = &btrfs_aops;
  2365. inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
  2366. BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
  2367. inode->i_fop = &btrfs_file_operations;
  2368. inode->i_op = &btrfs_file_inode_operations;
  2369. break;
  2370. case S_IFDIR:
  2371. inode->i_fop = &btrfs_dir_file_operations;
  2372. if (root == root->fs_info->tree_root)
  2373. inode->i_op = &btrfs_dir_ro_inode_operations;
  2374. else
  2375. inode->i_op = &btrfs_dir_inode_operations;
  2376. break;
  2377. case S_IFLNK:
  2378. inode->i_op = &btrfs_symlink_inode_operations;
  2379. inode->i_mapping->a_ops = &btrfs_symlink_aops;
  2380. inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
  2381. break;
  2382. default:
  2383. inode->i_op = &btrfs_special_inode_operations;
  2384. init_special_inode(inode, inode->i_mode, rdev);
  2385. break;
  2386. }
  2387. btrfs_update_iflags(inode);
  2388. return;
  2389. make_bad:
  2390. btrfs_free_path(path);
  2391. make_bad_inode(inode);
  2392. }
  2393. /*
  2394. * given a leaf and an inode, copy the inode fields into the leaf
  2395. */
  2396. static void fill_inode_item(struct btrfs_trans_handle *trans,
  2397. struct extent_buffer *leaf,
  2398. struct btrfs_inode_item *item,
  2399. struct inode *inode)
  2400. {
  2401. btrfs_set_inode_uid(leaf, item, i_uid_read(inode));
  2402. btrfs_set_inode_gid(leaf, item, i_gid_read(inode));
  2403. btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
  2404. btrfs_set_inode_mode(leaf, item, inode->i_mode);
  2405. btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
  2406. btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
  2407. inode->i_atime.tv_sec);
  2408. btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
  2409. inode->i_atime.tv_nsec);
  2410. btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
  2411. inode->i_mtime.tv_sec);
  2412. btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
  2413. inode->i_mtime.tv_nsec);
  2414. btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
  2415. inode->i_ctime.tv_sec);
  2416. btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
  2417. inode->i_ctime.tv_nsec);
  2418. btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
  2419. btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
  2420. btrfs_set_inode_sequence(leaf, item, inode->i_version);
  2421. btrfs_set_inode_transid(leaf, item, trans->transid);
  2422. btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
  2423. btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
  2424. btrfs_set_inode_block_group(leaf, item, 0);
  2425. }
  2426. /*
  2427. * copy everything in the in-memory inode into the btree.
  2428. */
  2429. static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
  2430. struct btrfs_root *root, struct inode *inode)
  2431. {
  2432. struct btrfs_inode_item *inode_item;
  2433. struct btrfs_path *path;
  2434. struct extent_buffer *leaf;
  2435. int ret;
  2436. path = btrfs_alloc_path();
  2437. if (!path)
  2438. return -ENOMEM;
  2439. path->leave_spinning = 1;
  2440. ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
  2441. 1);
  2442. if (ret) {
  2443. if (ret > 0)
  2444. ret = -ENOENT;
  2445. goto failed;
  2446. }
  2447. btrfs_unlock_up_safe(path, 1);
  2448. leaf = path->nodes[0];
  2449. inode_item = btrfs_item_ptr(leaf, path->slots[0],
  2450. struct btrfs_inode_item);
  2451. fill_inode_item(trans, leaf, inode_item, inode);
  2452. btrfs_mark_buffer_dirty(leaf);
  2453. btrfs_set_inode_last_trans(trans, inode);
  2454. ret = 0;
  2455. failed:
  2456. btrfs_free_path(path);
  2457. return ret;
  2458. }
  2459. /*
  2460. * copy everything in the in-memory inode into the btree.
  2461. */
  2462. noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
  2463. struct btrfs_root *root, struct inode *inode)
  2464. {
  2465. int ret;
  2466. /*
  2467. * If the inode is a free space inode, we can deadlock during commit
  2468. * if we put it into the delayed code.
  2469. *
  2470. * The data relocation inode should also be directly updated
  2471. * without delay
  2472. */
  2473. if (!btrfs_is_free_space_inode(inode)
  2474. && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
  2475. btrfs_update_root_times(trans, root);
  2476. ret = btrfs_delayed_update_inode(trans, root, inode);
  2477. if (!ret)
  2478. btrfs_set_inode_last_trans(trans, inode);
  2479. return ret;
  2480. }
  2481. return btrfs_update_inode_item(trans, root, inode);
  2482. }
  2483. noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
  2484. struct btrfs_root *root,
  2485. struct inode *inode)
  2486. {
  2487. int ret;
  2488. ret = btrfs_update_inode(trans, root, inode);
  2489. if (ret == -ENOSPC)
  2490. return btrfs_update_inode_item(trans, root, inode);
  2491. return ret;
  2492. }
  2493. /*
  2494. * unlink helper that gets used here in inode.c and in the tree logging
  2495. * recovery code. It remove a link in a directory with a given name, and
  2496. * also drops the back refs in the inode to the directory
  2497. */
  2498. static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
  2499. struct btrfs_root *root,
  2500. struct inode *dir, struct inode *inode,
  2501. const char *name, int name_len)
  2502. {
  2503. struct btrfs_path *path;
  2504. int ret = 0;
  2505. struct extent_buffer *leaf;
  2506. struct btrfs_dir_item *di;
  2507. struct btrfs_key key;
  2508. u64 index;
  2509. u64 ino = btrfs_ino(inode);
  2510. u64 dir_ino = btrfs_ino(dir);
  2511. path = btrfs_alloc_path();
  2512. if (!path) {
  2513. ret = -ENOMEM;
  2514. goto out;
  2515. }
  2516. path->leave_spinning = 1;
  2517. di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
  2518. name, name_len, -1);
  2519. if (IS_ERR(di)) {
  2520. ret = PTR_ERR(di);
  2521. goto err;
  2522. }
  2523. if (!di) {
  2524. ret = -ENOENT;
  2525. goto err;
  2526. }
  2527. leaf = path->nodes[0];
  2528. btrfs_dir_item_key_to_cpu(leaf, di, &key);
  2529. ret = btrfs_delete_one_dir_name(trans, root, path, di);
  2530. if (ret)
  2531. goto err;
  2532. btrfs_release_path(path);
  2533. ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
  2534. dir_ino, &index);
  2535. if (ret) {
  2536. printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
  2537. "inode %llu parent %llu\n", name_len, name,
  2538. (unsigned long long)ino, (unsigned long long)dir_ino);
  2539. btrfs_abort_transaction(trans, root, ret);
  2540. goto err;
  2541. }
  2542. ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
  2543. if (ret) {
  2544. btrfs_abort_transaction(trans, root, ret);
  2545. goto err;
  2546. }
  2547. ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
  2548. inode, dir_ino);
  2549. if (ret != 0 && ret != -ENOENT) {
  2550. btrfs_abort_transaction(trans, root, ret);
  2551. goto err;
  2552. }
  2553. ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
  2554. dir, index);
  2555. if (ret == -ENOENT)
  2556. ret = 0;
  2557. err:
  2558. btrfs_free_path(path);
  2559. if (ret)
  2560. goto out;
  2561. btrfs_i_size_write(dir, dir->i_size - name_len * 2);
  2562. inode_inc_iversion(inode);
  2563. inode_inc_iversion(dir);
  2564. inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
  2565. ret = btrfs_update_inode(trans, root, dir);
  2566. out:
  2567. return ret;
  2568. }
  2569. int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
  2570. struct btrfs_root *root,
  2571. struct inode *dir, struct inode *inode,
  2572. const char *name, int name_len)
  2573. {
  2574. int ret;
  2575. ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
  2576. if (!ret) {
  2577. btrfs_drop_nlink(inode);
  2578. ret = btrfs_update_inode(trans, root, inode);
  2579. }
  2580. return ret;
  2581. }
  2582. /* helper to check if there is any shared block in the path */
  2583. static int check_path_shared(struct btrfs_root *root,
  2584. struct btrfs_path *path)
  2585. {
  2586. struct extent_buffer *eb;
  2587. int level;
  2588. u64 refs = 1;
  2589. for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
  2590. int ret;
  2591. if (!path->nodes[level])
  2592. break;
  2593. eb = path->nodes[level];
  2594. if (!btrfs_block_can_be_shared(root, eb))
  2595. continue;
  2596. ret = btrfs_lookup_extent_info(NULL, root, eb->start, eb->len,
  2597. &refs, NULL);
  2598. if (refs > 1)
  2599. return 1;
  2600. }
  2601. return 0;
  2602. }
  2603. /*
  2604. * helper to start transaction for unlink and rmdir.
  2605. *
  2606. * unlink and rmdir are special in btrfs, they do not always free space.
  2607. * so in enospc case, we should make sure they will free space before
  2608. * allowing them to use the global metadata reservation.
  2609. */
  2610. static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
  2611. struct dentry *dentry)
  2612. {
  2613. struct btrfs_trans_handle *trans;
  2614. struct btrfs_root *root = BTRFS_I(dir)->root;
  2615. struct btrfs_path *path;
  2616. struct btrfs_dir_item *di;
  2617. struct inode *inode = dentry->d_inode;
  2618. u64 index;
  2619. int check_link = 1;
  2620. int err = -ENOSPC;
  2621. int ret;
  2622. u64 ino = btrfs_ino(inode);
  2623. u64 dir_ino = btrfs_ino(dir);
  2624. /*
  2625. * 1 for the possible orphan item
  2626. * 1 for the dir item
  2627. * 1 for the dir index
  2628. * 1 for the inode ref
  2629. * 1 for the inode ref in the tree log
  2630. * 2 for the dir entries in the log
  2631. * 1 for the inode
  2632. */
  2633. trans = btrfs_start_transaction(root, 8);
  2634. if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
  2635. return trans;
  2636. if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
  2637. return ERR_PTR(-ENOSPC);
  2638. /* check if there is someone else holds reference */
  2639. if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
  2640. return ERR_PTR(-ENOSPC);
  2641. if (atomic_read(&inode->i_count) > 2)
  2642. return ERR_PTR(-ENOSPC);
  2643. if (xchg(&root->fs_info->enospc_unlink, 1))
  2644. return ERR_PTR(-ENOSPC);
  2645. path = btrfs_alloc_path();
  2646. if (!path) {
  2647. root->fs_info->enospc_unlink = 0;
  2648. return ERR_PTR(-ENOMEM);
  2649. }
  2650. /* 1 for the orphan item */
  2651. trans = btrfs_start_transaction(root, 1);
  2652. if (IS_ERR(trans)) {
  2653. btrfs_free_path(path);
  2654. root->fs_info->enospc_unlink = 0;
  2655. return trans;
  2656. }
  2657. path->skip_locking = 1;
  2658. path->search_commit_root = 1;
  2659. ret = btrfs_lookup_inode(trans, root, path,
  2660. &BTRFS_I(dir)->location, 0);
  2661. if (ret < 0) {
  2662. err = ret;
  2663. goto out;
  2664. }
  2665. if (ret == 0) {
  2666. if (check_path_shared(root, path))
  2667. goto out;
  2668. } else {
  2669. check_link = 0;
  2670. }
  2671. btrfs_release_path(path);
  2672. ret = btrfs_lookup_inode(trans, root, path,
  2673. &BTRFS_I(inode)->location, 0);
  2674. if (ret < 0) {
  2675. err = ret;
  2676. goto out;
  2677. }
  2678. if (ret == 0) {
  2679. if (check_path_shared(root, path))
  2680. goto out;
  2681. } else {
  2682. check_link = 0;
  2683. }
  2684. btrfs_release_path(path);
  2685. if (ret == 0 && S_ISREG(inode->i_mode)) {
  2686. ret = btrfs_lookup_file_extent(trans, root, path,
  2687. ino, (u64)-1, 0);
  2688. if (ret < 0) {
  2689. err = ret;
  2690. goto out;
  2691. }
  2692. BUG_ON(ret == 0); /* Corruption */
  2693. if (check_path_shared(root, path))
  2694. goto out;
  2695. btrfs_release_path(path);
  2696. }
  2697. if (!check_link) {
  2698. err = 0;
  2699. goto out;
  2700. }
  2701. di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
  2702. dentry->d_name.name, dentry->d_name.len, 0);
  2703. if (IS_ERR(di)) {
  2704. err = PTR_ERR(di);
  2705. goto out;
  2706. }
  2707. if (di) {
  2708. if (check_path_shared(root, path))
  2709. goto out;
  2710. } else {
  2711. err = 0;
  2712. goto out;
  2713. }
  2714. btrfs_release_path(path);
  2715. ret = btrfs_get_inode_ref_index(trans, root, path, dentry->d_name.name,
  2716. dentry->d_name.len, ino, dir_ino, 0,
  2717. &index);
  2718. if (ret) {
  2719. err = ret;
  2720. goto out;
  2721. }
  2722. if (check_path_shared(root, path))
  2723. goto out;
  2724. btrfs_release_path(path);
  2725. /*
  2726. * This is a commit root search, if we can lookup inode item and other
  2727. * relative items in the commit root, it means the transaction of
  2728. * dir/file creation has been committed, and the dir index item that we
  2729. * delay to insert has also been inserted into the commit root. So
  2730. * we needn't worry about the delayed insertion of the dir index item
  2731. * here.
  2732. */
  2733. di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
  2734. dentry->d_name.name, dentry->d_name.len, 0);
  2735. if (IS_ERR(di)) {
  2736. err = PTR_ERR(di);
  2737. goto out;
  2738. }
  2739. BUG_ON(ret == -ENOENT);
  2740. if (check_path_shared(root, path))
  2741. goto out;
  2742. err = 0;
  2743. out:
  2744. btrfs_free_path(path);
  2745. /* Migrate the orphan reservation over */
  2746. if (!err)
  2747. err = btrfs_block_rsv_migrate(trans->block_rsv,
  2748. &root->fs_info->global_block_rsv,
  2749. trans->bytes_reserved);
  2750. if (err) {
  2751. btrfs_end_transaction(trans, root);
  2752. root->fs_info->enospc_unlink = 0;
  2753. return ERR_PTR(err);
  2754. }
  2755. trans->block_rsv = &root->fs_info->global_block_rsv;
  2756. return trans;
  2757. }
  2758. static void __unlink_end_trans(struct btrfs_trans_handle *trans,
  2759. struct btrfs_root *root)
  2760. {
  2761. if (trans->block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL) {
  2762. btrfs_block_rsv_release(root, trans->block_rsv,
  2763. trans->bytes_reserved);
  2764. trans->block_rsv = &root->fs_info->trans_block_rsv;
  2765. BUG_ON(!root->fs_info->enospc_unlink);
  2766. root->fs_info->enospc_unlink = 0;
  2767. }
  2768. btrfs_end_transaction(trans, root);
  2769. }
  2770. static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
  2771. {
  2772. struct btrfs_root *root = BTRFS_I(dir)->root;
  2773. struct btrfs_trans_handle *trans;
  2774. struct inode *inode = dentry->d_inode;
  2775. int ret;
  2776. trans = __unlink_start_trans(dir, dentry);
  2777. if (IS_ERR(trans))
  2778. return PTR_ERR(trans);
  2779. btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
  2780. ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
  2781. dentry->d_name.name, dentry->d_name.len);
  2782. if (ret)
  2783. goto out;
  2784. if (inode->i_nlink == 0) {
  2785. ret = btrfs_orphan_add(trans, inode);
  2786. if (ret)
  2787. goto out;
  2788. }
  2789. out:
  2790. __unlink_end_trans(trans, root);
  2791. btrfs_btree_balance_dirty(root);
  2792. return ret;
  2793. }
  2794. int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
  2795. struct btrfs_root *root,
  2796. struct inode *dir, u64 objectid,
  2797. const char *name, int name_len)
  2798. {
  2799. struct btrfs_path *path;
  2800. struct extent_buffer *leaf;
  2801. struct btrfs_dir_item *di;
  2802. struct btrfs_key key;
  2803. u64 index;
  2804. int ret;
  2805. u64 dir_ino = btrfs_ino(dir);
  2806. path = btrfs_alloc_path();
  2807. if (!path)
  2808. return -ENOMEM;
  2809. di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
  2810. name, name_len, -1);
  2811. if (IS_ERR_OR_NULL(di)) {
  2812. if (!di)
  2813. ret = -ENOENT;
  2814. else
  2815. ret = PTR_ERR(di);
  2816. goto out;
  2817. }
  2818. leaf = path->nodes[0];
  2819. btrfs_dir_item_key_to_cpu(leaf, di, &key);
  2820. WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
  2821. ret = btrfs_delete_one_dir_name(trans, root, path, di);
  2822. if (ret) {
  2823. btrfs_abort_transaction(trans, root, ret);
  2824. goto out;
  2825. }
  2826. btrfs_release_path(path);
  2827. ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
  2828. objectid, root->root_key.objectid,
  2829. dir_ino, &index, name, name_len);
  2830. if (ret < 0) {
  2831. if (ret != -ENOENT) {
  2832. btrfs_abort_transaction(trans, root, ret);
  2833. goto out;
  2834. }
  2835. di = btrfs_search_dir_index_item(root, path, dir_ino,
  2836. name, name_len);
  2837. if (IS_ERR_OR_NULL(di)) {
  2838. if (!di)
  2839. ret = -ENOENT;
  2840. else
  2841. ret = PTR_ERR(di);
  2842. btrfs_abort_transaction(trans, root, ret);
  2843. goto out;
  2844. }
  2845. leaf = path->nodes[0];
  2846. btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
  2847. btrfs_release_path(path);
  2848. index = key.offset;
  2849. }
  2850. btrfs_release_path(path);
  2851. ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
  2852. if (ret) {
  2853. btrfs_abort_transaction(trans, root, ret);
  2854. goto out;
  2855. }
  2856. btrfs_i_size_write(dir, dir->i_size - name_len * 2);
  2857. inode_inc_iversion(dir);
  2858. dir->i_mtime = dir->i_ctime = CURRENT_TIME;
  2859. ret = btrfs_update_inode_fallback(trans, root, dir);
  2860. if (ret)
  2861. btrfs_abort_transaction(trans, root, ret);
  2862. out:
  2863. btrfs_free_path(path);
  2864. return ret;
  2865. }
  2866. static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
  2867. {
  2868. struct inode *inode = dentry->d_inode;
  2869. int err = 0;
  2870. struct btrfs_root *root = BTRFS_I(dir)->root;
  2871. struct btrfs_trans_handle *trans;
  2872. if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
  2873. return -ENOTEMPTY;
  2874. if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
  2875. return -EPERM;
  2876. trans = __unlink_start_trans(dir, dentry);
  2877. if (IS_ERR(trans))
  2878. return PTR_ERR(trans);
  2879. if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
  2880. err = btrfs_unlink_subvol(trans, root, dir,
  2881. BTRFS_I(inode)->location.objectid,
  2882. dentry->d_name.name,
  2883. dentry->d_name.len);
  2884. goto out;
  2885. }
  2886. err = btrfs_orphan_add(trans, inode);
  2887. if (err)
  2888. goto out;
  2889. /* now the directory is empty */
  2890. err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
  2891. dentry->d_name.name, dentry->d_name.len);
  2892. if (!err)
  2893. btrfs_i_size_write(inode, 0);
  2894. out:
  2895. __unlink_end_trans(trans, root);
  2896. btrfs_btree_balance_dirty(root);
  2897. return err;
  2898. }
  2899. /*
  2900. * this can truncate away extent items, csum items and directory items.
  2901. * It starts at a high offset and removes keys until it can't find
  2902. * any higher than new_size
  2903. *
  2904. * csum items that cross the new i_size are truncated to the new size
  2905. * as well.
  2906. *
  2907. * min_type is the minimum key type to truncate down to. If set to 0, this
  2908. * will kill all the items on this inode, including the INODE_ITEM_KEY.
  2909. */
  2910. int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
  2911. struct btrfs_root *root,
  2912. struct inode *inode,
  2913. u64 new_size, u32 min_type)
  2914. {
  2915. struct btrfs_path *path;
  2916. struct extent_buffer *leaf;
  2917. struct btrfs_file_extent_item *fi;
  2918. struct btrfs_key key;
  2919. struct btrfs_key found_key;
  2920. u64 extent_start = 0;
  2921. u64 extent_num_bytes = 0;
  2922. u64 extent_offset = 0;
  2923. u64 item_end = 0;
  2924. u64 mask = root->sectorsize - 1;
  2925. u32 found_type = (u8)-1;
  2926. int found_extent;
  2927. int del_item;
  2928. int pending_del_nr = 0;
  2929. int pending_del_slot = 0;
  2930. int extent_type = -1;
  2931. int ret;
  2932. int err = 0;
  2933. u64 ino = btrfs_ino(inode);
  2934. BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
  2935. path = btrfs_alloc_path();
  2936. if (!path)
  2937. return -ENOMEM;
  2938. path->reada = -1;
  2939. /*
  2940. * We want to drop from the next block forward in case this new size is
  2941. * not block aligned since we will be keeping the last block of the
  2942. * extent just the way it is.
  2943. */
  2944. if (root->ref_cows || root == root->fs_info->tree_root)
  2945. btrfs_drop_extent_cache(inode, (new_size + mask) & (~mask), (u64)-1, 0);
  2946. /*
  2947. * This function is also used to drop the items in the log tree before
  2948. * we relog the inode, so if root != BTRFS_I(inode)->root, it means
  2949. * it is used to drop the loged items. So we shouldn't kill the delayed
  2950. * items.
  2951. */
  2952. if (min_type == 0 && root == BTRFS_I(inode)->root)
  2953. btrfs_kill_delayed_inode_items(inode);
  2954. key.objectid = ino;
  2955. key.offset = (u64)-1;
  2956. key.type = (u8)-1;
  2957. search_again:
  2958. path->leave_spinning = 1;
  2959. ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
  2960. if (ret < 0) {
  2961. err = ret;
  2962. goto out;
  2963. }
  2964. if (ret > 0) {
  2965. /* there are no items in the tree for us to truncate, we're
  2966. * done
  2967. */
  2968. if (path->slots[0] == 0)
  2969. goto out;
  2970. path->slots[0]--;
  2971. }
  2972. while (1) {
  2973. fi = NULL;
  2974. leaf = path->nodes[0];
  2975. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  2976. found_type = btrfs_key_type(&found_key);
  2977. if (found_key.objectid != ino)
  2978. break;
  2979. if (found_type < min_type)
  2980. break;
  2981. item_end = found_key.offset;
  2982. if (found_type == BTRFS_EXTENT_DATA_KEY) {
  2983. fi = btrfs_item_ptr(leaf, path->slots[0],
  2984. struct btrfs_file_extent_item);
  2985. extent_type = btrfs_file_extent_type(leaf, fi);
  2986. if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
  2987. item_end +=
  2988. btrfs_file_extent_num_bytes(leaf, fi);
  2989. } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
  2990. item_end += btrfs_file_extent_inline_len(leaf,
  2991. fi);
  2992. }
  2993. item_end--;
  2994. }
  2995. if (found_type > min_type) {
  2996. del_item = 1;
  2997. } else {
  2998. if (item_end < new_size)
  2999. break;
  3000. if (found_key.offset >= new_size)
  3001. del_item = 1;
  3002. else
  3003. del_item = 0;
  3004. }
  3005. found_extent = 0;
  3006. /* FIXME, shrink the extent if the ref count is only 1 */
  3007. if (found_type != BTRFS_EXTENT_DATA_KEY)
  3008. goto delete;
  3009. if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
  3010. u64 num_dec;
  3011. extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
  3012. if (!del_item) {
  3013. u64 orig_num_bytes =
  3014. btrfs_file_extent_num_bytes(leaf, fi);
  3015. extent_num_bytes = new_size -
  3016. found_key.offset + root->sectorsize - 1;
  3017. extent_num_bytes = extent_num_bytes &
  3018. ~((u64)root->sectorsize - 1);
  3019. btrfs_set_file_extent_num_bytes(leaf, fi,
  3020. extent_num_bytes);
  3021. num_dec = (orig_num_bytes -
  3022. extent_num_bytes);
  3023. if (root->ref_cows && extent_start != 0)
  3024. inode_sub_bytes(inode, num_dec);
  3025. btrfs_mark_buffer_dirty(leaf);
  3026. } else {
  3027. extent_num_bytes =
  3028. btrfs_file_extent_disk_num_bytes(leaf,
  3029. fi);
  3030. extent_offset = found_key.offset -
  3031. btrfs_file_extent_offset(leaf, fi);
  3032. /* FIXME blocksize != 4096 */
  3033. num_dec = btrfs_file_extent_num_bytes(leaf, fi);
  3034. if (extent_start != 0) {
  3035. found_extent = 1;
  3036. if (root->ref_cows)
  3037. inode_sub_bytes(inode, num_dec);
  3038. }
  3039. }
  3040. } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
  3041. /*
  3042. * we can't truncate inline items that have had
  3043. * special encodings
  3044. */
  3045. if (!del_item &&
  3046. btrfs_file_extent_compression(leaf, fi) == 0 &&
  3047. btrfs_file_extent_encryption(leaf, fi) == 0 &&
  3048. btrfs_file_extent_other_encoding(leaf, fi) == 0) {
  3049. u32 size = new_size - found_key.offset;
  3050. if (root->ref_cows) {
  3051. inode_sub_bytes(inode, item_end + 1 -
  3052. new_size);
  3053. }
  3054. size =
  3055. btrfs_file_extent_calc_inline_size(size);
  3056. btrfs_truncate_item(trans, root, path,
  3057. size, 1);
  3058. } else if (root->ref_cows) {
  3059. inode_sub_bytes(inode, item_end + 1 -
  3060. found_key.offset);
  3061. }
  3062. }
  3063. delete:
  3064. if (del_item) {
  3065. if (!pending_del_nr) {
  3066. /* no pending yet, add ourselves */
  3067. pending_del_slot = path->slots[0];
  3068. pending_del_nr = 1;
  3069. } else if (pending_del_nr &&
  3070. path->slots[0] + 1 == pending_del_slot) {
  3071. /* hop on the pending chunk */
  3072. pending_del_nr++;
  3073. pending_del_slot = path->slots[0];
  3074. } else {
  3075. BUG();
  3076. }
  3077. } else {
  3078. break;
  3079. }
  3080. if (found_extent && (root->ref_cows ||
  3081. root == root->fs_info->tree_root)) {
  3082. btrfs_set_path_blocking(path);
  3083. ret = btrfs_free_extent(trans, root, extent_start,
  3084. extent_num_bytes, 0,
  3085. btrfs_header_owner(leaf),
  3086. ino, extent_offset, 0);
  3087. BUG_ON(ret);
  3088. }
  3089. if (found_type == BTRFS_INODE_ITEM_KEY)
  3090. break;
  3091. if (path->slots[0] == 0 ||
  3092. path->slots[0] != pending_del_slot) {
  3093. if (pending_del_nr) {
  3094. ret = btrfs_del_items(trans, root, path,
  3095. pending_del_slot,
  3096. pending_del_nr);
  3097. if (ret) {
  3098. btrfs_abort_transaction(trans,
  3099. root, ret);
  3100. goto error;
  3101. }
  3102. pending_del_nr = 0;
  3103. }
  3104. btrfs_release_path(path);
  3105. goto search_again;
  3106. } else {
  3107. path->slots[0]--;
  3108. }
  3109. }
  3110. out:
  3111. if (pending_del_nr) {
  3112. ret = btrfs_del_items(trans, root, path, pending_del_slot,
  3113. pending_del_nr);
  3114. if (ret)
  3115. btrfs_abort_transaction(trans, root, ret);
  3116. }
  3117. error:
  3118. btrfs_free_path(path);
  3119. return err;
  3120. }
  3121. /*
  3122. * btrfs_truncate_page - read, zero a chunk and write a page
  3123. * @inode - inode that we're zeroing
  3124. * @from - the offset to start zeroing
  3125. * @len - the length to zero, 0 to zero the entire range respective to the
  3126. * offset
  3127. * @front - zero up to the offset instead of from the offset on
  3128. *
  3129. * This will find the page for the "from" offset and cow the page and zero the
  3130. * part we want to zero. This is used with truncate and hole punching.
  3131. */
  3132. int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
  3133. int front)
  3134. {
  3135. struct address_space *mapping = inode->i_mapping;
  3136. struct btrfs_root *root = BTRFS_I(inode)->root;
  3137. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  3138. struct btrfs_ordered_extent *ordered;
  3139. struct extent_state *cached_state = NULL;
  3140. char *kaddr;
  3141. u32 blocksize = root->sectorsize;
  3142. pgoff_t index = from >> PAGE_CACHE_SHIFT;
  3143. unsigned offset = from & (PAGE_CACHE_SIZE-1);
  3144. struct page *page;
  3145. gfp_t mask = btrfs_alloc_write_mask(mapping);
  3146. int ret = 0;
  3147. u64 page_start;
  3148. u64 page_end;
  3149. if ((offset & (blocksize - 1)) == 0 &&
  3150. (!len || ((len & (blocksize - 1)) == 0)))
  3151. goto out;
  3152. ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
  3153. if (ret)
  3154. goto out;
  3155. again:
  3156. page = find_or_create_page(mapping, index, mask);
  3157. if (!page) {
  3158. btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
  3159. ret = -ENOMEM;
  3160. goto out;
  3161. }
  3162. page_start = page_offset(page);
  3163. page_end = page_start + PAGE_CACHE_SIZE - 1;
  3164. if (!PageUptodate(page)) {
  3165. ret = btrfs_readpage(NULL, page);
  3166. lock_page(page);
  3167. if (page->mapping != mapping) {
  3168. unlock_page(page);
  3169. page_cache_release(page);
  3170. goto again;
  3171. }
  3172. if (!PageUptodate(page)) {
  3173. ret = -EIO;
  3174. goto out_unlock;
  3175. }
  3176. }
  3177. wait_on_page_writeback(page);
  3178. lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
  3179. set_page_extent_mapped(page);
  3180. ordered = btrfs_lookup_ordered_extent(inode, page_start);
  3181. if (ordered) {
  3182. unlock_extent_cached(io_tree, page_start, page_end,
  3183. &cached_state, GFP_NOFS);
  3184. unlock_page(page);
  3185. page_cache_release(page);
  3186. btrfs_start_ordered_extent(inode, ordered, 1);
  3187. btrfs_put_ordered_extent(ordered);
  3188. goto again;
  3189. }
  3190. clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
  3191. EXTENT_DIRTY | EXTENT_DELALLOC |
  3192. EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
  3193. 0, 0, &cached_state, GFP_NOFS);
  3194. ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
  3195. &cached_state);
  3196. if (ret) {
  3197. unlock_extent_cached(io_tree, page_start, page_end,
  3198. &cached_state, GFP_NOFS);
  3199. goto out_unlock;
  3200. }
  3201. if (offset != PAGE_CACHE_SIZE) {
  3202. if (!len)
  3203. len = PAGE_CACHE_SIZE - offset;
  3204. kaddr = kmap(page);
  3205. if (front)
  3206. memset(kaddr, 0, offset);
  3207. else
  3208. memset(kaddr + offset, 0, len);
  3209. flush_dcache_page(page);
  3210. kunmap(page);
  3211. }
  3212. ClearPageChecked(page);
  3213. set_page_dirty(page);
  3214. unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
  3215. GFP_NOFS);
  3216. out_unlock:
  3217. if (ret)
  3218. btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
  3219. unlock_page(page);
  3220. page_cache_release(page);
  3221. out:
  3222. return ret;
  3223. }
  3224. /*
  3225. * This function puts in dummy file extents for the area we're creating a hole
  3226. * for. So if we are truncating this file to a larger size we need to insert
  3227. * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
  3228. * the range between oldsize and size
  3229. */
  3230. int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
  3231. {
  3232. struct btrfs_trans_handle *trans;
  3233. struct btrfs_root *root = BTRFS_I(inode)->root;
  3234. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  3235. struct extent_map *em = NULL;
  3236. struct extent_state *cached_state = NULL;
  3237. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  3238. u64 mask = root->sectorsize - 1;
  3239. u64 hole_start = (oldsize + mask) & ~mask;
  3240. u64 block_end = (size + mask) & ~mask;
  3241. u64 last_byte;
  3242. u64 cur_offset;
  3243. u64 hole_size;
  3244. int err = 0;
  3245. if (size <= hole_start)
  3246. return 0;
  3247. while (1) {
  3248. struct btrfs_ordered_extent *ordered;
  3249. btrfs_wait_ordered_range(inode, hole_start,
  3250. block_end - hole_start);
  3251. lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
  3252. &cached_state);
  3253. ordered = btrfs_lookup_ordered_extent(inode, hole_start);
  3254. if (!ordered)
  3255. break;
  3256. unlock_extent_cached(io_tree, hole_start, block_end - 1,
  3257. &cached_state, GFP_NOFS);
  3258. btrfs_put_ordered_extent(ordered);
  3259. }
  3260. cur_offset = hole_start;
  3261. while (1) {
  3262. em = btrfs_get_extent(inode, NULL, 0, cur_offset,
  3263. block_end - cur_offset, 0);
  3264. if (IS_ERR(em)) {
  3265. err = PTR_ERR(em);
  3266. em = NULL;
  3267. break;
  3268. }
  3269. last_byte = min(extent_map_end(em), block_end);
  3270. last_byte = (last_byte + mask) & ~mask;
  3271. if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
  3272. struct extent_map *hole_em;
  3273. hole_size = last_byte - cur_offset;
  3274. trans = btrfs_start_transaction(root, 3);
  3275. if (IS_ERR(trans)) {
  3276. err = PTR_ERR(trans);
  3277. break;
  3278. }
  3279. err = btrfs_drop_extents(trans, root, inode,
  3280. cur_offset,
  3281. cur_offset + hole_size, 1);
  3282. if (err) {
  3283. btrfs_abort_transaction(trans, root, err);
  3284. btrfs_end_transaction(trans, root);
  3285. break;
  3286. }
  3287. err = btrfs_insert_file_extent(trans, root,
  3288. btrfs_ino(inode), cur_offset, 0,
  3289. 0, hole_size, 0, hole_size,
  3290. 0, 0, 0);
  3291. if (err) {
  3292. btrfs_abort_transaction(trans, root, err);
  3293. btrfs_end_transaction(trans, root);
  3294. break;
  3295. }
  3296. btrfs_drop_extent_cache(inode, cur_offset,
  3297. cur_offset + hole_size - 1, 0);
  3298. hole_em = alloc_extent_map();
  3299. if (!hole_em) {
  3300. set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
  3301. &BTRFS_I(inode)->runtime_flags);
  3302. goto next;
  3303. }
  3304. hole_em->start = cur_offset;
  3305. hole_em->len = hole_size;
  3306. hole_em->orig_start = cur_offset;
  3307. hole_em->block_start = EXTENT_MAP_HOLE;
  3308. hole_em->block_len = 0;
  3309. hole_em->orig_block_len = 0;
  3310. hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
  3311. hole_em->compress_type = BTRFS_COMPRESS_NONE;
  3312. hole_em->generation = trans->transid;
  3313. while (1) {
  3314. write_lock(&em_tree->lock);
  3315. err = add_extent_mapping(em_tree, hole_em);
  3316. if (!err)
  3317. list_move(&hole_em->list,
  3318. &em_tree->modified_extents);
  3319. write_unlock(&em_tree->lock);
  3320. if (err != -EEXIST)
  3321. break;
  3322. btrfs_drop_extent_cache(inode, cur_offset,
  3323. cur_offset +
  3324. hole_size - 1, 0);
  3325. }
  3326. free_extent_map(hole_em);
  3327. next:
  3328. btrfs_update_inode(trans, root, inode);
  3329. btrfs_end_transaction(trans, root);
  3330. }
  3331. free_extent_map(em);
  3332. em = NULL;
  3333. cur_offset = last_byte;
  3334. if (cur_offset >= block_end)
  3335. break;
  3336. }
  3337. free_extent_map(em);
  3338. unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
  3339. GFP_NOFS);
  3340. return err;
  3341. }
  3342. static int btrfs_setsize(struct inode *inode, struct iattr *attr)
  3343. {
  3344. struct btrfs_root *root = BTRFS_I(inode)->root;
  3345. struct btrfs_trans_handle *trans;
  3346. loff_t oldsize = i_size_read(inode);
  3347. loff_t newsize = attr->ia_size;
  3348. int mask = attr->ia_valid;
  3349. int ret;
  3350. if (newsize == oldsize)
  3351. return 0;
  3352. /*
  3353. * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
  3354. * special case where we need to update the times despite not having
  3355. * these flags set. For all other operations the VFS set these flags
  3356. * explicitly if it wants a timestamp update.
  3357. */
  3358. if (newsize != oldsize && (!(mask & (ATTR_CTIME | ATTR_MTIME))))
  3359. inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
  3360. if (newsize > oldsize) {
  3361. truncate_pagecache(inode, oldsize, newsize);
  3362. ret = btrfs_cont_expand(inode, oldsize, newsize);
  3363. if (ret)
  3364. return ret;
  3365. trans = btrfs_start_transaction(root, 1);
  3366. if (IS_ERR(trans))
  3367. return PTR_ERR(trans);
  3368. i_size_write(inode, newsize);
  3369. btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
  3370. ret = btrfs_update_inode(trans, root, inode);
  3371. btrfs_end_transaction(trans, root);
  3372. } else {
  3373. /*
  3374. * We're truncating a file that used to have good data down to
  3375. * zero. Make sure it gets into the ordered flush list so that
  3376. * any new writes get down to disk quickly.
  3377. */
  3378. if (newsize == 0)
  3379. set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
  3380. &BTRFS_I(inode)->runtime_flags);
  3381. /*
  3382. * 1 for the orphan item we're going to add
  3383. * 1 for the orphan item deletion.
  3384. */
  3385. trans = btrfs_start_transaction(root, 2);
  3386. if (IS_ERR(trans))
  3387. return PTR_ERR(trans);
  3388. /*
  3389. * We need to do this in case we fail at _any_ point during the
  3390. * actual truncate. Once we do the truncate_setsize we could
  3391. * invalidate pages which forces any outstanding ordered io to
  3392. * be instantly completed which will give us extents that need
  3393. * to be truncated. If we fail to get an orphan inode down we
  3394. * could have left over extents that were never meant to live,
  3395. * so we need to garuntee from this point on that everything
  3396. * will be consistent.
  3397. */
  3398. ret = btrfs_orphan_add(trans, inode);
  3399. btrfs_end_transaction(trans, root);
  3400. if (ret)
  3401. return ret;
  3402. /* we don't support swapfiles, so vmtruncate shouldn't fail */
  3403. truncate_setsize(inode, newsize);
  3404. ret = btrfs_truncate(inode);
  3405. if (ret && inode->i_nlink)
  3406. btrfs_orphan_del(NULL, inode);
  3407. }
  3408. return ret;
  3409. }
  3410. static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
  3411. {
  3412. struct inode *inode = dentry->d_inode;
  3413. struct btrfs_root *root = BTRFS_I(inode)->root;
  3414. int err;
  3415. if (btrfs_root_readonly(root))
  3416. return -EROFS;
  3417. err = inode_change_ok(inode, attr);
  3418. if (err)
  3419. return err;
  3420. if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
  3421. err = btrfs_setsize(inode, attr);
  3422. if (err)
  3423. return err;
  3424. }
  3425. if (attr->ia_valid) {
  3426. setattr_copy(inode, attr);
  3427. inode_inc_iversion(inode);
  3428. err = btrfs_dirty_inode(inode);
  3429. if (!err && attr->ia_valid & ATTR_MODE)
  3430. err = btrfs_acl_chmod(inode);
  3431. }
  3432. return err;
  3433. }
  3434. void btrfs_evict_inode(struct inode *inode)
  3435. {
  3436. struct btrfs_trans_handle *trans;
  3437. struct btrfs_root *root = BTRFS_I(inode)->root;
  3438. struct btrfs_block_rsv *rsv, *global_rsv;
  3439. u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
  3440. int ret;
  3441. trace_btrfs_inode_evict(inode);
  3442. truncate_inode_pages(&inode->i_data, 0);
  3443. if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
  3444. btrfs_is_free_space_inode(inode)))
  3445. goto no_delete;
  3446. if (is_bad_inode(inode)) {
  3447. btrfs_orphan_del(NULL, inode);
  3448. goto no_delete;
  3449. }
  3450. /* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
  3451. btrfs_wait_ordered_range(inode, 0, (u64)-1);
  3452. if (root->fs_info->log_root_recovering) {
  3453. BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  3454. &BTRFS_I(inode)->runtime_flags));
  3455. goto no_delete;
  3456. }
  3457. if (inode->i_nlink > 0) {
  3458. BUG_ON(btrfs_root_refs(&root->root_item) != 0);
  3459. goto no_delete;
  3460. }
  3461. rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
  3462. if (!rsv) {
  3463. btrfs_orphan_del(NULL, inode);
  3464. goto no_delete;
  3465. }
  3466. rsv->size = min_size;
  3467. rsv->failfast = 1;
  3468. global_rsv = &root->fs_info->global_block_rsv;
  3469. btrfs_i_size_write(inode, 0);
  3470. /*
  3471. * This is a bit simpler than btrfs_truncate since we've already
  3472. * reserved our space for our orphan item in the unlink, so we just
  3473. * need to reserve some slack space in case we add bytes and update
  3474. * inode item when doing the truncate.
  3475. */
  3476. while (1) {
  3477. ret = btrfs_block_rsv_refill(root, rsv, min_size,
  3478. BTRFS_RESERVE_FLUSH_LIMIT);
  3479. /*
  3480. * Try and steal from the global reserve since we will
  3481. * likely not use this space anyway, we want to try as
  3482. * hard as possible to get this to work.
  3483. */
  3484. if (ret)
  3485. ret = btrfs_block_rsv_migrate(global_rsv, rsv, min_size);
  3486. if (ret) {
  3487. printk(KERN_WARNING "Could not get space for a "
  3488. "delete, will truncate on mount %d\n", ret);
  3489. btrfs_orphan_del(NULL, inode);
  3490. btrfs_free_block_rsv(root, rsv);
  3491. goto no_delete;
  3492. }
  3493. trans = btrfs_start_transaction_lflush(root, 1);
  3494. if (IS_ERR(trans)) {
  3495. btrfs_orphan_del(NULL, inode);
  3496. btrfs_free_block_rsv(root, rsv);
  3497. goto no_delete;
  3498. }
  3499. trans->block_rsv = rsv;
  3500. ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
  3501. if (ret != -ENOSPC)
  3502. break;
  3503. trans->block_rsv = &root->fs_info->trans_block_rsv;
  3504. ret = btrfs_update_inode(trans, root, inode);
  3505. BUG_ON(ret);
  3506. btrfs_end_transaction(trans, root);
  3507. trans = NULL;
  3508. btrfs_btree_balance_dirty(root);
  3509. }
  3510. btrfs_free_block_rsv(root, rsv);
  3511. if (ret == 0) {
  3512. trans->block_rsv = root->orphan_block_rsv;
  3513. ret = btrfs_orphan_del(trans, inode);
  3514. BUG_ON(ret);
  3515. }
  3516. trans->block_rsv = &root->fs_info->trans_block_rsv;
  3517. if (!(root == root->fs_info->tree_root ||
  3518. root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
  3519. btrfs_return_ino(root, btrfs_ino(inode));
  3520. btrfs_end_transaction(trans, root);
  3521. btrfs_btree_balance_dirty(root);
  3522. no_delete:
  3523. clear_inode(inode);
  3524. return;
  3525. }
  3526. /*
  3527. * this returns the key found in the dir entry in the location pointer.
  3528. * If no dir entries were found, location->objectid is 0.
  3529. */
  3530. static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
  3531. struct btrfs_key *location)
  3532. {
  3533. const char *name = dentry->d_name.name;
  3534. int namelen = dentry->d_name.len;
  3535. struct btrfs_dir_item *di;
  3536. struct btrfs_path *path;
  3537. struct btrfs_root *root = BTRFS_I(dir)->root;
  3538. int ret = 0;
  3539. path = btrfs_alloc_path();
  3540. if (!path)
  3541. return -ENOMEM;
  3542. di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
  3543. namelen, 0);
  3544. if (IS_ERR(di))
  3545. ret = PTR_ERR(di);
  3546. if (IS_ERR_OR_NULL(di))
  3547. goto out_err;
  3548. btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
  3549. out:
  3550. btrfs_free_path(path);
  3551. return ret;
  3552. out_err:
  3553. location->objectid = 0;
  3554. goto out;
  3555. }
  3556. /*
  3557. * when we hit a tree root in a directory, the btrfs part of the inode
  3558. * needs to be changed to reflect the root directory of the tree root. This
  3559. * is kind of like crossing a mount point.
  3560. */
  3561. static int fixup_tree_root_location(struct btrfs_root *root,
  3562. struct inode *dir,
  3563. struct dentry *dentry,
  3564. struct btrfs_key *location,
  3565. struct btrfs_root **sub_root)
  3566. {
  3567. struct btrfs_path *path;
  3568. struct btrfs_root *new_root;
  3569. struct btrfs_root_ref *ref;
  3570. struct extent_buffer *leaf;
  3571. int ret;
  3572. int err = 0;
  3573. path = btrfs_alloc_path();
  3574. if (!path) {
  3575. err = -ENOMEM;
  3576. goto out;
  3577. }
  3578. err = -ENOENT;
  3579. ret = btrfs_find_root_ref(root->fs_info->tree_root, path,
  3580. BTRFS_I(dir)->root->root_key.objectid,
  3581. location->objectid);
  3582. if (ret) {
  3583. if (ret < 0)
  3584. err = ret;
  3585. goto out;
  3586. }
  3587. leaf = path->nodes[0];
  3588. ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
  3589. if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
  3590. btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
  3591. goto out;
  3592. ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
  3593. (unsigned long)(ref + 1),
  3594. dentry->d_name.len);
  3595. if (ret)
  3596. goto out;
  3597. btrfs_release_path(path);
  3598. new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
  3599. if (IS_ERR(new_root)) {
  3600. err = PTR_ERR(new_root);
  3601. goto out;
  3602. }
  3603. if (btrfs_root_refs(&new_root->root_item) == 0) {
  3604. err = -ENOENT;
  3605. goto out;
  3606. }
  3607. *sub_root = new_root;
  3608. location->objectid = btrfs_root_dirid(&new_root->root_item);
  3609. location->type = BTRFS_INODE_ITEM_KEY;
  3610. location->offset = 0;
  3611. err = 0;
  3612. out:
  3613. btrfs_free_path(path);
  3614. return err;
  3615. }
  3616. static void inode_tree_add(struct inode *inode)
  3617. {
  3618. struct btrfs_root *root = BTRFS_I(inode)->root;
  3619. struct btrfs_inode *entry;
  3620. struct rb_node **p;
  3621. struct rb_node *parent;
  3622. u64 ino = btrfs_ino(inode);
  3623. again:
  3624. p = &root->inode_tree.rb_node;
  3625. parent = NULL;
  3626. if (inode_unhashed(inode))
  3627. return;
  3628. spin_lock(&root->inode_lock);
  3629. while (*p) {
  3630. parent = *p;
  3631. entry = rb_entry(parent, struct btrfs_inode, rb_node);
  3632. if (ino < btrfs_ino(&entry->vfs_inode))
  3633. p = &parent->rb_left;
  3634. else if (ino > btrfs_ino(&entry->vfs_inode))
  3635. p = &parent->rb_right;
  3636. else {
  3637. WARN_ON(!(entry->vfs_inode.i_state &
  3638. (I_WILL_FREE | I_FREEING)));
  3639. rb_erase(parent, &root->inode_tree);
  3640. RB_CLEAR_NODE(parent);
  3641. spin_unlock(&root->inode_lock);
  3642. goto again;
  3643. }
  3644. }
  3645. rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
  3646. rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
  3647. spin_unlock(&root->inode_lock);
  3648. }
  3649. static void inode_tree_del(struct inode *inode)
  3650. {
  3651. struct btrfs_root *root = BTRFS_I(inode)->root;
  3652. int empty = 0;
  3653. spin_lock(&root->inode_lock);
  3654. if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
  3655. rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
  3656. RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
  3657. empty = RB_EMPTY_ROOT(&root->inode_tree);
  3658. }
  3659. spin_unlock(&root->inode_lock);
  3660. /*
  3661. * Free space cache has inodes in the tree root, but the tree root has a
  3662. * root_refs of 0, so this could end up dropping the tree root as a
  3663. * snapshot, so we need the extra !root->fs_info->tree_root check to
  3664. * make sure we don't drop it.
  3665. */
  3666. if (empty && btrfs_root_refs(&root->root_item) == 0 &&
  3667. root != root->fs_info->tree_root) {
  3668. synchronize_srcu(&root->fs_info->subvol_srcu);
  3669. spin_lock(&root->inode_lock);
  3670. empty = RB_EMPTY_ROOT(&root->inode_tree);
  3671. spin_unlock(&root->inode_lock);
  3672. if (empty)
  3673. btrfs_add_dead_root(root);
  3674. }
  3675. }
  3676. void btrfs_invalidate_inodes(struct btrfs_root *root)
  3677. {
  3678. struct rb_node *node;
  3679. struct rb_node *prev;
  3680. struct btrfs_inode *entry;
  3681. struct inode *inode;
  3682. u64 objectid = 0;
  3683. WARN_ON(btrfs_root_refs(&root->root_item) != 0);
  3684. spin_lock(&root->inode_lock);
  3685. again:
  3686. node = root->inode_tree.rb_node;
  3687. prev = NULL;
  3688. while (node) {
  3689. prev = node;
  3690. entry = rb_entry(node, struct btrfs_inode, rb_node);
  3691. if (objectid < btrfs_ino(&entry->vfs_inode))
  3692. node = node->rb_left;
  3693. else if (objectid > btrfs_ino(&entry->vfs_inode))
  3694. node = node->rb_right;
  3695. else
  3696. break;
  3697. }
  3698. if (!node) {
  3699. while (prev) {
  3700. entry = rb_entry(prev, struct btrfs_inode, rb_node);
  3701. if (objectid <= btrfs_ino(&entry->vfs_inode)) {
  3702. node = prev;
  3703. break;
  3704. }
  3705. prev = rb_next(prev);
  3706. }
  3707. }
  3708. while (node) {
  3709. entry = rb_entry(node, struct btrfs_inode, rb_node);
  3710. objectid = btrfs_ino(&entry->vfs_inode) + 1;
  3711. inode = igrab(&entry->vfs_inode);
  3712. if (inode) {
  3713. spin_unlock(&root->inode_lock);
  3714. if (atomic_read(&inode->i_count) > 1)
  3715. d_prune_aliases(inode);
  3716. /*
  3717. * btrfs_drop_inode will have it removed from
  3718. * the inode cache when its usage count
  3719. * hits zero.
  3720. */
  3721. iput(inode);
  3722. cond_resched();
  3723. spin_lock(&root->inode_lock);
  3724. goto again;
  3725. }
  3726. if (cond_resched_lock(&root->inode_lock))
  3727. goto again;
  3728. node = rb_next(node);
  3729. }
  3730. spin_unlock(&root->inode_lock);
  3731. }
  3732. static int btrfs_init_locked_inode(struct inode *inode, void *p)
  3733. {
  3734. struct btrfs_iget_args *args = p;
  3735. inode->i_ino = args->ino;
  3736. BTRFS_I(inode)->root = args->root;
  3737. return 0;
  3738. }
  3739. static int btrfs_find_actor(struct inode *inode, void *opaque)
  3740. {
  3741. struct btrfs_iget_args *args = opaque;
  3742. return args->ino == btrfs_ino(inode) &&
  3743. args->root == BTRFS_I(inode)->root;
  3744. }
  3745. static struct inode *btrfs_iget_locked(struct super_block *s,
  3746. u64 objectid,
  3747. struct btrfs_root *root)
  3748. {
  3749. struct inode *inode;
  3750. struct btrfs_iget_args args;
  3751. args.ino = objectid;
  3752. args.root = root;
  3753. inode = iget5_locked(s, objectid, btrfs_find_actor,
  3754. btrfs_init_locked_inode,
  3755. (void *)&args);
  3756. return inode;
  3757. }
  3758. /* Get an inode object given its location and corresponding root.
  3759. * Returns in *is_new if the inode was read from disk
  3760. */
  3761. struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
  3762. struct btrfs_root *root, int *new)
  3763. {
  3764. struct inode *inode;
  3765. inode = btrfs_iget_locked(s, location->objectid, root);
  3766. if (!inode)
  3767. return ERR_PTR(-ENOMEM);
  3768. if (inode->i_state & I_NEW) {
  3769. BTRFS_I(inode)->root = root;
  3770. memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
  3771. btrfs_read_locked_inode(inode);
  3772. if (!is_bad_inode(inode)) {
  3773. inode_tree_add(inode);
  3774. unlock_new_inode(inode);
  3775. if (new)
  3776. *new = 1;
  3777. } else {
  3778. unlock_new_inode(inode);
  3779. iput(inode);
  3780. inode = ERR_PTR(-ESTALE);
  3781. }
  3782. }
  3783. return inode;
  3784. }
  3785. static struct inode *new_simple_dir(struct super_block *s,
  3786. struct btrfs_key *key,
  3787. struct btrfs_root *root)
  3788. {
  3789. struct inode *inode = new_inode(s);
  3790. if (!inode)
  3791. return ERR_PTR(-ENOMEM);
  3792. BTRFS_I(inode)->root = root;
  3793. memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
  3794. set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
  3795. inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
  3796. inode->i_op = &btrfs_dir_ro_inode_operations;
  3797. inode->i_fop = &simple_dir_operations;
  3798. inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
  3799. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  3800. return inode;
  3801. }
  3802. struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
  3803. {
  3804. struct inode *inode;
  3805. struct btrfs_root *root = BTRFS_I(dir)->root;
  3806. struct btrfs_root *sub_root = root;
  3807. struct btrfs_key location;
  3808. int index;
  3809. int ret = 0;
  3810. if (dentry->d_name.len > BTRFS_NAME_LEN)
  3811. return ERR_PTR(-ENAMETOOLONG);
  3812. if (unlikely(d_need_lookup(dentry))) {
  3813. memcpy(&location, dentry->d_fsdata, sizeof(struct btrfs_key));
  3814. kfree(dentry->d_fsdata);
  3815. dentry->d_fsdata = NULL;
  3816. /* This thing is hashed, drop it for now */
  3817. d_drop(dentry);
  3818. } else {
  3819. ret = btrfs_inode_by_name(dir, dentry, &location);
  3820. }
  3821. if (ret < 0)
  3822. return ERR_PTR(ret);
  3823. if (location.objectid == 0)
  3824. return NULL;
  3825. if (location.type == BTRFS_INODE_ITEM_KEY) {
  3826. inode = btrfs_iget(dir->i_sb, &location, root, NULL);
  3827. return inode;
  3828. }
  3829. BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);
  3830. index = srcu_read_lock(&root->fs_info->subvol_srcu);
  3831. ret = fixup_tree_root_location(root, dir, dentry,
  3832. &location, &sub_root);
  3833. if (ret < 0) {
  3834. if (ret != -ENOENT)
  3835. inode = ERR_PTR(ret);
  3836. else
  3837. inode = new_simple_dir(dir->i_sb, &location, sub_root);
  3838. } else {
  3839. inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
  3840. }
  3841. srcu_read_unlock(&root->fs_info->subvol_srcu, index);
  3842. if (!IS_ERR(inode) && root != sub_root) {
  3843. down_read(&root->fs_info->cleanup_work_sem);
  3844. if (!(inode->i_sb->s_flags & MS_RDONLY))
  3845. ret = btrfs_orphan_cleanup(sub_root);
  3846. up_read(&root->fs_info->cleanup_work_sem);
  3847. if (ret)
  3848. inode = ERR_PTR(ret);
  3849. }
  3850. return inode;
  3851. }
  3852. static int btrfs_dentry_delete(const struct dentry *dentry)
  3853. {
  3854. struct btrfs_root *root;
  3855. struct inode *inode = dentry->d_inode;
  3856. if (!inode && !IS_ROOT(dentry))
  3857. inode = dentry->d_parent->d_inode;
  3858. if (inode) {
  3859. root = BTRFS_I(inode)->root;
  3860. if (btrfs_root_refs(&root->root_item) == 0)
  3861. return 1;
  3862. if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
  3863. return 1;
  3864. }
  3865. return 0;
  3866. }
  3867. static void btrfs_dentry_release(struct dentry *dentry)
  3868. {
  3869. if (dentry->d_fsdata)
  3870. kfree(dentry->d_fsdata);
  3871. }
  3872. static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
  3873. unsigned int flags)
  3874. {
  3875. struct dentry *ret;
  3876. ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
  3877. if (unlikely(d_need_lookup(dentry))) {
  3878. spin_lock(&dentry->d_lock);
  3879. dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
  3880. spin_unlock(&dentry->d_lock);
  3881. }
  3882. return ret;
  3883. }
  3884. unsigned char btrfs_filetype_table[] = {
  3885. DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
  3886. };
  3887. static int btrfs_real_readdir(struct file *filp, void *dirent,
  3888. filldir_t filldir)
  3889. {
  3890. struct inode *inode = filp->f_dentry->d_inode;
  3891. struct btrfs_root *root = BTRFS_I(inode)->root;
  3892. struct btrfs_item *item;
  3893. struct btrfs_dir_item *di;
  3894. struct btrfs_key key;
  3895. struct btrfs_key found_key;
  3896. struct btrfs_path *path;
  3897. struct list_head ins_list;
  3898. struct list_head del_list;
  3899. int ret;
  3900. struct extent_buffer *leaf;
  3901. int slot;
  3902. unsigned char d_type;
  3903. int over = 0;
  3904. u32 di_cur;
  3905. u32 di_total;
  3906. u32 di_len;
  3907. int key_type = BTRFS_DIR_INDEX_KEY;
  3908. char tmp_name[32];
  3909. char *name_ptr;
  3910. int name_len;
  3911. int is_curr = 0; /* filp->f_pos points to the current index? */
  3912. /* FIXME, use a real flag for deciding about the key type */
  3913. if (root->fs_info->tree_root == root)
  3914. key_type = BTRFS_DIR_ITEM_KEY;
  3915. /* special case for "." */
  3916. if (filp->f_pos == 0) {
  3917. over = filldir(dirent, ".", 1,
  3918. filp->f_pos, btrfs_ino(inode), DT_DIR);
  3919. if (over)
  3920. return 0;
  3921. filp->f_pos = 1;
  3922. }
  3923. /* special case for .., just use the back ref */
  3924. if (filp->f_pos == 1) {
  3925. u64 pino = parent_ino(filp->f_path.dentry);
  3926. over = filldir(dirent, "..", 2,
  3927. filp->f_pos, pino, DT_DIR);
  3928. if (over)
  3929. return 0;
  3930. filp->f_pos = 2;
  3931. }
  3932. path = btrfs_alloc_path();
  3933. if (!path)
  3934. return -ENOMEM;
  3935. path->reada = 1;
  3936. if (key_type == BTRFS_DIR_INDEX_KEY) {
  3937. INIT_LIST_HEAD(&ins_list);
  3938. INIT_LIST_HEAD(&del_list);
  3939. btrfs_get_delayed_items(inode, &ins_list, &del_list);
  3940. }
  3941. btrfs_set_key_type(&key, key_type);
  3942. key.offset = filp->f_pos;
  3943. key.objectid = btrfs_ino(inode);
  3944. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  3945. if (ret < 0)
  3946. goto err;
  3947. while (1) {
  3948. leaf = path->nodes[0];
  3949. slot = path->slots[0];
  3950. if (slot >= btrfs_header_nritems(leaf)) {
  3951. ret = btrfs_next_leaf(root, path);
  3952. if (ret < 0)
  3953. goto err;
  3954. else if (ret > 0)
  3955. break;
  3956. continue;
  3957. }
  3958. item = btrfs_item_nr(leaf, slot);
  3959. btrfs_item_key_to_cpu(leaf, &found_key, slot);
  3960. if (found_key.objectid != key.objectid)
  3961. break;
  3962. if (btrfs_key_type(&found_key) != key_type)
  3963. break;
  3964. if (found_key.offset < filp->f_pos)
  3965. goto next;
  3966. if (key_type == BTRFS_DIR_INDEX_KEY &&
  3967. btrfs_should_delete_dir_index(&del_list,
  3968. found_key.offset))
  3969. goto next;
  3970. filp->f_pos = found_key.offset;
  3971. is_curr = 1;
  3972. di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
  3973. di_cur = 0;
  3974. di_total = btrfs_item_size(leaf, item);
  3975. while (di_cur < di_total) {
  3976. struct btrfs_key location;
  3977. if (verify_dir_item(root, leaf, di))
  3978. break;
  3979. name_len = btrfs_dir_name_len(leaf, di);
  3980. if (name_len <= sizeof(tmp_name)) {
  3981. name_ptr = tmp_name;
  3982. } else {
  3983. name_ptr = kmalloc(name_len, GFP_NOFS);
  3984. if (!name_ptr) {
  3985. ret = -ENOMEM;
  3986. goto err;
  3987. }
  3988. }
  3989. read_extent_buffer(leaf, name_ptr,
  3990. (unsigned long)(di + 1), name_len);
  3991. d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
  3992. btrfs_dir_item_key_to_cpu(leaf, di, &location);
  3993. /* is this a reference to our own snapshot? If so
  3994. * skip it.
  3995. *
  3996. * In contrast to old kernels, we insert the snapshot's
  3997. * dir item and dir index after it has been created, so
  3998. * we won't find a reference to our own snapshot. We
  3999. * still keep the following code for backward
  4000. * compatibility.
  4001. */
  4002. if (location.type == BTRFS_ROOT_ITEM_KEY &&
  4003. location.objectid == root->root_key.objectid) {
  4004. over = 0;
  4005. goto skip;
  4006. }
  4007. over = filldir(dirent, name_ptr, name_len,
  4008. found_key.offset, location.objectid,
  4009. d_type);
  4010. skip:
  4011. if (name_ptr != tmp_name)
  4012. kfree(name_ptr);
  4013. if (over)
  4014. goto nopos;
  4015. di_len = btrfs_dir_name_len(leaf, di) +
  4016. btrfs_dir_data_len(leaf, di) + sizeof(*di);
  4017. di_cur += di_len;
  4018. di = (struct btrfs_dir_item *)((char *)di + di_len);
  4019. }
  4020. next:
  4021. path->slots[0]++;
  4022. }
  4023. if (key_type == BTRFS_DIR_INDEX_KEY) {
  4024. if (is_curr)
  4025. filp->f_pos++;
  4026. ret = btrfs_readdir_delayed_dir_index(filp, dirent, filldir,
  4027. &ins_list);
  4028. if (ret)
  4029. goto nopos;
  4030. }
  4031. /* Reached end of directory/root. Bump pos past the last item. */
  4032. if (key_type == BTRFS_DIR_INDEX_KEY)
  4033. /*
  4034. * 32-bit glibc will use getdents64, but then strtol -
  4035. * so the last number we can serve is this.
  4036. */
  4037. filp->f_pos = 0x7fffffff;
  4038. else
  4039. filp->f_pos++;
  4040. nopos:
  4041. ret = 0;
  4042. err:
  4043. if (key_type == BTRFS_DIR_INDEX_KEY)
  4044. btrfs_put_delayed_items(&ins_list, &del_list);
  4045. btrfs_free_path(path);
  4046. return ret;
  4047. }
  4048. int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
  4049. {
  4050. struct btrfs_root *root = BTRFS_I(inode)->root;
  4051. struct btrfs_trans_handle *trans;
  4052. int ret = 0;
  4053. bool nolock = false;
  4054. if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
  4055. return 0;
  4056. if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
  4057. nolock = true;
  4058. if (wbc->sync_mode == WB_SYNC_ALL) {
  4059. if (nolock)
  4060. trans = btrfs_join_transaction_nolock(root);
  4061. else
  4062. trans = btrfs_join_transaction(root);
  4063. if (IS_ERR(trans))
  4064. return PTR_ERR(trans);
  4065. ret = btrfs_commit_transaction(trans, root);
  4066. }
  4067. return ret;
  4068. }
  4069. /*
  4070. * This is somewhat expensive, updating the tree every time the
  4071. * inode changes. But, it is most likely to find the inode in cache.
  4072. * FIXME, needs more benchmarking...there are no reasons other than performance
  4073. * to keep or drop this code.
  4074. */
  4075. int btrfs_dirty_inode(struct inode *inode)
  4076. {
  4077. struct btrfs_root *root = BTRFS_I(inode)->root;
  4078. struct btrfs_trans_handle *trans;
  4079. int ret;
  4080. if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
  4081. return 0;
  4082. trans = btrfs_join_transaction(root);
  4083. if (IS_ERR(trans))
  4084. return PTR_ERR(trans);
  4085. ret = btrfs_update_inode(trans, root, inode);
  4086. if (ret && ret == -ENOSPC) {
  4087. /* whoops, lets try again with the full transaction */
  4088. btrfs_end_transaction(trans, root);
  4089. trans = btrfs_start_transaction(root, 1);
  4090. if (IS_ERR(trans))
  4091. return PTR_ERR(trans);
  4092. ret = btrfs_update_inode(trans, root, inode);
  4093. }
  4094. btrfs_end_transaction(trans, root);
  4095. if (BTRFS_I(inode)->delayed_node)
  4096. btrfs_balance_delayed_items(root);
  4097. return ret;
  4098. }
  4099. /*
  4100. * This is a copy of file_update_time. We need this so we can return error on
  4101. * ENOSPC for updating the inode in the case of file write and mmap writes.
  4102. */
  4103. static int btrfs_update_time(struct inode *inode, struct timespec *now,
  4104. int flags)
  4105. {
  4106. struct btrfs_root *root = BTRFS_I(inode)->root;
  4107. if (btrfs_root_readonly(root))
  4108. return -EROFS;
  4109. if (flags & S_VERSION)
  4110. inode_inc_iversion(inode);
  4111. if (flags & S_CTIME)
  4112. inode->i_ctime = *now;
  4113. if (flags & S_MTIME)
  4114. inode->i_mtime = *now;
  4115. if (flags & S_ATIME)
  4116. inode->i_atime = *now;
  4117. return btrfs_dirty_inode(inode);
  4118. }
  4119. /*
  4120. * find the highest existing sequence number in a directory
  4121. * and then set the in-memory index_cnt variable to reflect
  4122. * free sequence numbers
  4123. */
  4124. static int btrfs_set_inode_index_count(struct inode *inode)
  4125. {
  4126. struct btrfs_root *root = BTRFS_I(inode)->root;
  4127. struct btrfs_key key, found_key;
  4128. struct btrfs_path *path;
  4129. struct extent_buffer *leaf;
  4130. int ret;
  4131. key.objectid = btrfs_ino(inode);
  4132. btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
  4133. key.offset = (u64)-1;
  4134. path = btrfs_alloc_path();
  4135. if (!path)
  4136. return -ENOMEM;
  4137. ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  4138. if (ret < 0)
  4139. goto out;
  4140. /* FIXME: we should be able to handle this */
  4141. if (ret == 0)
  4142. goto out;
  4143. ret = 0;
  4144. /*
  4145. * MAGIC NUMBER EXPLANATION:
  4146. * since we search a directory based on f_pos we have to start at 2
  4147. * since '.' and '..' have f_pos of 0 and 1 respectively, so everybody
  4148. * else has to start at 2
  4149. */
  4150. if (path->slots[0] == 0) {
  4151. BTRFS_I(inode)->index_cnt = 2;
  4152. goto out;
  4153. }
  4154. path->slots[0]--;
  4155. leaf = path->nodes[0];
  4156. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  4157. if (found_key.objectid != btrfs_ino(inode) ||
  4158. btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
  4159. BTRFS_I(inode)->index_cnt = 2;
  4160. goto out;
  4161. }
  4162. BTRFS_I(inode)->index_cnt = found_key.offset + 1;
  4163. out:
  4164. btrfs_free_path(path);
  4165. return ret;
  4166. }
  4167. /*
  4168. * helper to find a free sequence number in a given directory. This current
  4169. * code is very simple, later versions will do smarter things in the btree
  4170. */
  4171. int btrfs_set_inode_index(struct inode *dir, u64 *index)
  4172. {
  4173. int ret = 0;
  4174. if (BTRFS_I(dir)->index_cnt == (u64)-1) {
  4175. ret = btrfs_inode_delayed_dir_index_count(dir);
  4176. if (ret) {
  4177. ret = btrfs_set_inode_index_count(dir);
  4178. if (ret)
  4179. return ret;
  4180. }
  4181. }
  4182. *index = BTRFS_I(dir)->index_cnt;
  4183. BTRFS_I(dir)->index_cnt++;
  4184. return ret;
  4185. }
  4186. static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
  4187. struct btrfs_root *root,
  4188. struct inode *dir,
  4189. const char *name, int name_len,
  4190. u64 ref_objectid, u64 objectid,
  4191. umode_t mode, u64 *index)
  4192. {
  4193. struct inode *inode;
  4194. struct btrfs_inode_item *inode_item;
  4195. struct btrfs_key *location;
  4196. struct btrfs_path *path;
  4197. struct btrfs_inode_ref *ref;
  4198. struct btrfs_key key[2];
  4199. u32 sizes[2];
  4200. unsigned long ptr;
  4201. int ret;
  4202. int owner;
  4203. path = btrfs_alloc_path();
  4204. if (!path)
  4205. return ERR_PTR(-ENOMEM);
  4206. inode = new_inode(root->fs_info->sb);
  4207. if (!inode) {
  4208. btrfs_free_path(path);
  4209. return ERR_PTR(-ENOMEM);
  4210. }
  4211. /*
  4212. * we have to initialize this early, so we can reclaim the inode
  4213. * number if we fail afterwards in this function.
  4214. */
  4215. inode->i_ino = objectid;
  4216. if (dir) {
  4217. trace_btrfs_inode_request(dir);
  4218. ret = btrfs_set_inode_index(dir, index);
  4219. if (ret) {
  4220. btrfs_free_path(path);
  4221. iput(inode);
  4222. return ERR_PTR(ret);
  4223. }
  4224. }
  4225. /*
  4226. * index_cnt is ignored for everything but a dir,
  4227. * btrfs_get_inode_index_count has an explanation for the magic
  4228. * number
  4229. */
  4230. BTRFS_I(inode)->index_cnt = 2;
  4231. BTRFS_I(inode)->root = root;
  4232. BTRFS_I(inode)->generation = trans->transid;
  4233. inode->i_generation = BTRFS_I(inode)->generation;
  4234. /*
  4235. * We could have gotten an inode number from somebody who was fsynced
  4236. * and then removed in this same transaction, so let's just set full
  4237. * sync since it will be a full sync anyway and this will blow away the
  4238. * old info in the log.
  4239. */
  4240. set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
  4241. if (S_ISDIR(mode))
  4242. owner = 0;
  4243. else
  4244. owner = 1;
  4245. key[0].objectid = objectid;
  4246. btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
  4247. key[0].offset = 0;
  4248. /*
  4249. * Start new inodes with an inode_ref. This is slightly more
  4250. * efficient for small numbers of hard links since they will
  4251. * be packed into one item. Extended refs will kick in if we
  4252. * add more hard links than can fit in the ref item.
  4253. */
  4254. key[1].objectid = objectid;
  4255. btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
  4256. key[1].offset = ref_objectid;
  4257. sizes[0] = sizeof(struct btrfs_inode_item);
  4258. sizes[1] = name_len + sizeof(*ref);
  4259. path->leave_spinning = 1;
  4260. ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
  4261. if (ret != 0)
  4262. goto fail;
  4263. inode_init_owner(inode, dir, mode);
  4264. inode_set_bytes(inode, 0);
  4265. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  4266. inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
  4267. struct btrfs_inode_item);
  4268. memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
  4269. sizeof(*inode_item));
  4270. fill_inode_item(trans, path->nodes[0], inode_item, inode);
  4271. ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
  4272. struct btrfs_inode_ref);
  4273. btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
  4274. btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
  4275. ptr = (unsigned long)(ref + 1);
  4276. write_extent_buffer(path->nodes[0], name, ptr, name_len);
  4277. btrfs_mark_buffer_dirty(path->nodes[0]);
  4278. btrfs_free_path(path);
  4279. location = &BTRFS_I(inode)->location;
  4280. location->objectid = objectid;
  4281. location->offset = 0;
  4282. btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
  4283. btrfs_inherit_iflags(inode, dir);
  4284. if (S_ISREG(mode)) {
  4285. if (btrfs_test_opt(root, NODATASUM))
  4286. BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
  4287. if (btrfs_test_opt(root, NODATACOW))
  4288. BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
  4289. }
  4290. insert_inode_hash(inode);
  4291. inode_tree_add(inode);
  4292. trace_btrfs_inode_new(inode);
  4293. btrfs_set_inode_last_trans(trans, inode);
  4294. btrfs_update_root_times(trans, root);
  4295. return inode;
  4296. fail:
  4297. if (dir)
  4298. BTRFS_I(dir)->index_cnt--;
  4299. btrfs_free_path(path);
  4300. iput(inode);
  4301. return ERR_PTR(ret);
  4302. }
  4303. static inline u8 btrfs_inode_type(struct inode *inode)
  4304. {
  4305. return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
  4306. }
  4307. /*
  4308. * utility function to add 'inode' into 'parent_inode' with
  4309. * a give name and a given sequence number.
  4310. * if 'add_backref' is true, also insert a backref from the
  4311. * inode to the parent directory.
  4312. */
  4313. int btrfs_add_link(struct btrfs_trans_handle *trans,
  4314. struct inode *parent_inode, struct inode *inode,
  4315. const char *name, int name_len, int add_backref, u64 index)
  4316. {
  4317. int ret = 0;
  4318. struct btrfs_key key;
  4319. struct btrfs_root *root = BTRFS_I(parent_inode)->root;
  4320. u64 ino = btrfs_ino(inode);
  4321. u64 parent_ino = btrfs_ino(parent_inode);
  4322. if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
  4323. memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
  4324. } else {
  4325. key.objectid = ino;
  4326. btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
  4327. key.offset = 0;
  4328. }
  4329. if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
  4330. ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
  4331. key.objectid, root->root_key.objectid,
  4332. parent_ino, index, name, name_len);
  4333. } else if (add_backref) {
  4334. ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
  4335. parent_ino, index);
  4336. }
  4337. /* Nothing to clean up yet */
  4338. if (ret)
  4339. return ret;
  4340. ret = btrfs_insert_dir_item(trans, root, name, name_len,
  4341. parent_inode, &key,
  4342. btrfs_inode_type(inode), index);
  4343. if (ret == -EEXIST || ret == -EOVERFLOW)
  4344. goto fail_dir_item;
  4345. else if (ret) {
  4346. btrfs_abort_transaction(trans, root, ret);
  4347. return ret;
  4348. }
  4349. btrfs_i_size_write(parent_inode, parent_inode->i_size +
  4350. name_len * 2);
  4351. inode_inc_iversion(parent_inode);
  4352. parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
  4353. ret = btrfs_update_inode(trans, root, parent_inode);
  4354. if (ret)
  4355. btrfs_abort_transaction(trans, root, ret);
  4356. return ret;
  4357. fail_dir_item:
  4358. if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
  4359. u64 local_index;
  4360. int err;
  4361. err = btrfs_del_root_ref(trans, root->fs_info->tree_root,
  4362. key.objectid, root->root_key.objectid,
  4363. parent_ino, &local_index, name, name_len);
  4364. } else if (add_backref) {
  4365. u64 local_index;
  4366. int err;
  4367. err = btrfs_del_inode_ref(trans, root, name, name_len,
  4368. ino, parent_ino, &local_index);
  4369. }
  4370. return ret;
  4371. }
  4372. static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
  4373. struct inode *dir, struct dentry *dentry,
  4374. struct inode *inode, int backref, u64 index)
  4375. {
  4376. int err = btrfs_add_link(trans, dir, inode,
  4377. dentry->d_name.name, dentry->d_name.len,
  4378. backref, index);
  4379. if (err > 0)
  4380. err = -EEXIST;
  4381. return err;
  4382. }
  4383. static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
  4384. umode_t mode, dev_t rdev)
  4385. {
  4386. struct btrfs_trans_handle *trans;
  4387. struct btrfs_root *root = BTRFS_I(dir)->root;
  4388. struct inode *inode = NULL;
  4389. int err;
  4390. int drop_inode = 0;
  4391. u64 objectid;
  4392. u64 index = 0;
  4393. if (!new_valid_dev(rdev))
  4394. return -EINVAL;
  4395. /*
  4396. * 2 for inode item and ref
  4397. * 2 for dir items
  4398. * 1 for xattr if selinux is on
  4399. */
  4400. trans = btrfs_start_transaction(root, 5);
  4401. if (IS_ERR(trans))
  4402. return PTR_ERR(trans);
  4403. err = btrfs_find_free_ino(root, &objectid);
  4404. if (err)
  4405. goto out_unlock;
  4406. inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
  4407. dentry->d_name.len, btrfs_ino(dir), objectid,
  4408. mode, &index);
  4409. if (IS_ERR(inode)) {
  4410. err = PTR_ERR(inode);
  4411. goto out_unlock;
  4412. }
  4413. err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
  4414. if (err) {
  4415. drop_inode = 1;
  4416. goto out_unlock;
  4417. }
  4418. err = btrfs_update_inode(trans, root, inode);
  4419. if (err) {
  4420. drop_inode = 1;
  4421. goto out_unlock;
  4422. }
  4423. /*
  4424. * If the active LSM wants to access the inode during
  4425. * d_instantiate it needs these. Smack checks to see
  4426. * if the filesystem supports xattrs by looking at the
  4427. * ops vector.
  4428. */
  4429. inode->i_op = &btrfs_special_inode_operations;
  4430. err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
  4431. if (err)
  4432. drop_inode = 1;
  4433. else {
  4434. init_special_inode(inode, inode->i_mode, rdev);
  4435. btrfs_update_inode(trans, root, inode);
  4436. d_instantiate(dentry, inode);
  4437. }
  4438. out_unlock:
  4439. btrfs_end_transaction(trans, root);
  4440. btrfs_btree_balance_dirty(root);
  4441. if (drop_inode) {
  4442. inode_dec_link_count(inode);
  4443. iput(inode);
  4444. }
  4445. return err;
  4446. }
  4447. static int btrfs_create(struct inode *dir, struct dentry *dentry,
  4448. umode_t mode, bool excl)
  4449. {
  4450. struct btrfs_trans_handle *trans;
  4451. struct btrfs_root *root = BTRFS_I(dir)->root;
  4452. struct inode *inode = NULL;
  4453. int drop_inode_on_err = 0;
  4454. int err;
  4455. u64 objectid;
  4456. u64 index = 0;
  4457. /*
  4458. * 2 for inode item and ref
  4459. * 2 for dir items
  4460. * 1 for xattr if selinux is on
  4461. */
  4462. trans = btrfs_start_transaction(root, 5);
  4463. if (IS_ERR(trans))
  4464. return PTR_ERR(trans);
  4465. err = btrfs_find_free_ino(root, &objectid);
  4466. if (err)
  4467. goto out_unlock;
  4468. inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
  4469. dentry->d_name.len, btrfs_ino(dir), objectid,
  4470. mode, &index);
  4471. if (IS_ERR(inode)) {
  4472. err = PTR_ERR(inode);
  4473. goto out_unlock;
  4474. }
  4475. drop_inode_on_err = 1;
  4476. err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
  4477. if (err)
  4478. goto out_unlock;
  4479. err = btrfs_update_inode(trans, root, inode);
  4480. if (err)
  4481. goto out_unlock;
  4482. /*
  4483. * If the active LSM wants to access the inode during
  4484. * d_instantiate it needs these. Smack checks to see
  4485. * if the filesystem supports xattrs by looking at the
  4486. * ops vector.
  4487. */
  4488. inode->i_fop = &btrfs_file_operations;
  4489. inode->i_op = &btrfs_file_inode_operations;
  4490. err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
  4491. if (err)
  4492. goto out_unlock;
  4493. inode->i_mapping->a_ops = &btrfs_aops;
  4494. inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
  4495. BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
  4496. d_instantiate(dentry, inode);
  4497. out_unlock:
  4498. btrfs_end_transaction(trans, root);
  4499. if (err && drop_inode_on_err) {
  4500. inode_dec_link_count(inode);
  4501. iput(inode);
  4502. }
  4503. btrfs_btree_balance_dirty(root);
  4504. return err;
  4505. }
  4506. static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
  4507. struct dentry *dentry)
  4508. {
  4509. struct btrfs_trans_handle *trans;
  4510. struct btrfs_root *root = BTRFS_I(dir)->root;
  4511. struct inode *inode = old_dentry->d_inode;
  4512. u64 index;
  4513. int err;
  4514. int drop_inode = 0;
  4515. /* do not allow sys_link's with other subvols of the same device */
  4516. if (root->objectid != BTRFS_I(inode)->root->objectid)
  4517. return -EXDEV;
  4518. if (inode->i_nlink >= BTRFS_LINK_MAX)
  4519. return -EMLINK;
  4520. err = btrfs_set_inode_index(dir, &index);
  4521. if (err)
  4522. goto fail;
  4523. /*
  4524. * 2 items for inode and inode ref
  4525. * 2 items for dir items
  4526. * 1 item for parent inode
  4527. */
  4528. trans = btrfs_start_transaction(root, 5);
  4529. if (IS_ERR(trans)) {
  4530. err = PTR_ERR(trans);
  4531. goto fail;
  4532. }
  4533. btrfs_inc_nlink(inode);
  4534. inode_inc_iversion(inode);
  4535. inode->i_ctime = CURRENT_TIME;
  4536. ihold(inode);
  4537. set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
  4538. err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
  4539. if (err) {
  4540. drop_inode = 1;
  4541. } else {
  4542. struct dentry *parent = dentry->d_parent;
  4543. err = btrfs_update_inode(trans, root, inode);
  4544. if (err)
  4545. goto fail;
  4546. d_instantiate(dentry, inode);
  4547. btrfs_log_new_name(trans, inode, NULL, parent);
  4548. }
  4549. btrfs_end_transaction(trans, root);
  4550. fail:
  4551. if (drop_inode) {
  4552. inode_dec_link_count(inode);
  4553. iput(inode);
  4554. }
  4555. btrfs_btree_balance_dirty(root);
  4556. return err;
  4557. }
  4558. static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
  4559. {
  4560. struct inode *inode = NULL;
  4561. struct btrfs_trans_handle *trans;
  4562. struct btrfs_root *root = BTRFS_I(dir)->root;
  4563. int err = 0;
  4564. int drop_on_err = 0;
  4565. u64 objectid = 0;
  4566. u64 index = 0;
  4567. /*
  4568. * 2 items for inode and ref
  4569. * 2 items for dir items
  4570. * 1 for xattr if selinux is on
  4571. */
  4572. trans = btrfs_start_transaction(root, 5);
  4573. if (IS_ERR(trans))
  4574. return PTR_ERR(trans);
  4575. err = btrfs_find_free_ino(root, &objectid);
  4576. if (err)
  4577. goto out_fail;
  4578. inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
  4579. dentry->d_name.len, btrfs_ino(dir), objectid,
  4580. S_IFDIR | mode, &index);
  4581. if (IS_ERR(inode)) {
  4582. err = PTR_ERR(inode);
  4583. goto out_fail;
  4584. }
  4585. drop_on_err = 1;
  4586. err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
  4587. if (err)
  4588. goto out_fail;
  4589. inode->i_op = &btrfs_dir_inode_operations;
  4590. inode->i_fop = &btrfs_dir_file_operations;
  4591. btrfs_i_size_write(inode, 0);
  4592. err = btrfs_update_inode(trans, root, inode);
  4593. if (err)
  4594. goto out_fail;
  4595. err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
  4596. dentry->d_name.len, 0, index);
  4597. if (err)
  4598. goto out_fail;
  4599. d_instantiate(dentry, inode);
  4600. drop_on_err = 0;
  4601. out_fail:
  4602. btrfs_end_transaction(trans, root);
  4603. if (drop_on_err)
  4604. iput(inode);
  4605. btrfs_btree_balance_dirty(root);
  4606. return err;
  4607. }
  4608. /* helper for btfs_get_extent. Given an existing extent in the tree,
  4609. * and an extent that you want to insert, deal with overlap and insert
  4610. * the new extent into the tree.
  4611. */
  4612. static int merge_extent_mapping(struct extent_map_tree *em_tree,
  4613. struct extent_map *existing,
  4614. struct extent_map *em,
  4615. u64 map_start, u64 map_len)
  4616. {
  4617. u64 start_diff;
  4618. BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
  4619. start_diff = map_start - em->start;
  4620. em->start = map_start;
  4621. em->len = map_len;
  4622. if (em->block_start < EXTENT_MAP_LAST_BYTE &&
  4623. !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
  4624. em->block_start += start_diff;
  4625. em->block_len -= start_diff;
  4626. }
  4627. return add_extent_mapping(em_tree, em);
  4628. }
  4629. static noinline int uncompress_inline(struct btrfs_path *path,
  4630. struct inode *inode, struct page *page,
  4631. size_t pg_offset, u64 extent_offset,
  4632. struct btrfs_file_extent_item *item)
  4633. {
  4634. int ret;
  4635. struct extent_buffer *leaf = path->nodes[0];
  4636. char *tmp;
  4637. size_t max_size;
  4638. unsigned long inline_size;
  4639. unsigned long ptr;
  4640. int compress_type;
  4641. WARN_ON(pg_offset != 0);
  4642. compress_type = btrfs_file_extent_compression(leaf, item);
  4643. max_size = btrfs_file_extent_ram_bytes(leaf, item);
  4644. inline_size = btrfs_file_extent_inline_item_len(leaf,
  4645. btrfs_item_nr(leaf, path->slots[0]));
  4646. tmp = kmalloc(inline_size, GFP_NOFS);
  4647. if (!tmp)
  4648. return -ENOMEM;
  4649. ptr = btrfs_file_extent_inline_start(item);
  4650. read_extent_buffer(leaf, tmp, ptr, inline_size);
  4651. max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
  4652. ret = btrfs_decompress(compress_type, tmp, page,
  4653. extent_offset, inline_size, max_size);
  4654. if (ret) {
  4655. char *kaddr = kmap_atomic(page);
  4656. unsigned long copy_size = min_t(u64,
  4657. PAGE_CACHE_SIZE - pg_offset,
  4658. max_size - extent_offset);
  4659. memset(kaddr + pg_offset, 0, copy_size);
  4660. kunmap_atomic(kaddr);
  4661. }
  4662. kfree(tmp);
  4663. return 0;
  4664. }
  4665. /*
  4666. * a bit scary, this does extent mapping from logical file offset to the disk.
  4667. * the ugly parts come from merging extents from the disk with the in-ram
  4668. * representation. This gets more complex because of the data=ordered code,
  4669. * where the in-ram extents might be locked pending data=ordered completion.
  4670. *
  4671. * This also copies inline extents directly into the page.
  4672. */
  4673. struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
  4674. size_t pg_offset, u64 start, u64 len,
  4675. int create)
  4676. {
  4677. int ret;
  4678. int err = 0;
  4679. u64 bytenr;
  4680. u64 extent_start = 0;
  4681. u64 extent_end = 0;
  4682. u64 objectid = btrfs_ino(inode);
  4683. u32 found_type;
  4684. struct btrfs_path *path = NULL;
  4685. struct btrfs_root *root = BTRFS_I(inode)->root;
  4686. struct btrfs_file_extent_item *item;
  4687. struct extent_buffer *leaf;
  4688. struct btrfs_key found_key;
  4689. struct extent_map *em = NULL;
  4690. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  4691. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  4692. struct btrfs_trans_handle *trans = NULL;
  4693. int compress_type;
  4694. again:
  4695. read_lock(&em_tree->lock);
  4696. em = lookup_extent_mapping(em_tree, start, len);
  4697. if (em)
  4698. em->bdev = root->fs_info->fs_devices->latest_bdev;
  4699. read_unlock(&em_tree->lock);
  4700. if (em) {
  4701. if (em->start > start || em->start + em->len <= start)
  4702. free_extent_map(em);
  4703. else if (em->block_start == EXTENT_MAP_INLINE && page)
  4704. free_extent_map(em);
  4705. else
  4706. goto out;
  4707. }
  4708. em = alloc_extent_map();
  4709. if (!em) {
  4710. err = -ENOMEM;
  4711. goto out;
  4712. }
  4713. em->bdev = root->fs_info->fs_devices->latest_bdev;
  4714. em->start = EXTENT_MAP_HOLE;
  4715. em->orig_start = EXTENT_MAP_HOLE;
  4716. em->len = (u64)-1;
  4717. em->block_len = (u64)-1;
  4718. if (!path) {
  4719. path = btrfs_alloc_path();
  4720. if (!path) {
  4721. err = -ENOMEM;
  4722. goto out;
  4723. }
  4724. /*
  4725. * Chances are we'll be called again, so go ahead and do
  4726. * readahead
  4727. */
  4728. path->reada = 1;
  4729. }
  4730. ret = btrfs_lookup_file_extent(trans, root, path,
  4731. objectid, start, trans != NULL);
  4732. if (ret < 0) {
  4733. err = ret;
  4734. goto out;
  4735. }
  4736. if (ret != 0) {
  4737. if (path->slots[0] == 0)
  4738. goto not_found;
  4739. path->slots[0]--;
  4740. }
  4741. leaf = path->nodes[0];
  4742. item = btrfs_item_ptr(leaf, path->slots[0],
  4743. struct btrfs_file_extent_item);
  4744. /* are we inside the extent that was found? */
  4745. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  4746. found_type = btrfs_key_type(&found_key);
  4747. if (found_key.objectid != objectid ||
  4748. found_type != BTRFS_EXTENT_DATA_KEY) {
  4749. goto not_found;
  4750. }
  4751. found_type = btrfs_file_extent_type(leaf, item);
  4752. extent_start = found_key.offset;
  4753. compress_type = btrfs_file_extent_compression(leaf, item);
  4754. if (found_type == BTRFS_FILE_EXTENT_REG ||
  4755. found_type == BTRFS_FILE_EXTENT_PREALLOC) {
  4756. extent_end = extent_start +
  4757. btrfs_file_extent_num_bytes(leaf, item);
  4758. } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
  4759. size_t size;
  4760. size = btrfs_file_extent_inline_len(leaf, item);
  4761. extent_end = (extent_start + size + root->sectorsize - 1) &
  4762. ~((u64)root->sectorsize - 1);
  4763. }
  4764. if (start >= extent_end) {
  4765. path->slots[0]++;
  4766. if (path->slots[0] >= btrfs_header_nritems(leaf)) {
  4767. ret = btrfs_next_leaf(root, path);
  4768. if (ret < 0) {
  4769. err = ret;
  4770. goto out;
  4771. }
  4772. if (ret > 0)
  4773. goto not_found;
  4774. leaf = path->nodes[0];
  4775. }
  4776. btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
  4777. if (found_key.objectid != objectid ||
  4778. found_key.type != BTRFS_EXTENT_DATA_KEY)
  4779. goto not_found;
  4780. if (start + len <= found_key.offset)
  4781. goto not_found;
  4782. em->start = start;
  4783. em->orig_start = start;
  4784. em->len = found_key.offset - start;
  4785. goto not_found_em;
  4786. }
  4787. if (found_type == BTRFS_FILE_EXTENT_REG ||
  4788. found_type == BTRFS_FILE_EXTENT_PREALLOC) {
  4789. em->start = extent_start;
  4790. em->len = extent_end - extent_start;
  4791. em->orig_start = extent_start -
  4792. btrfs_file_extent_offset(leaf, item);
  4793. em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
  4794. item);
  4795. bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
  4796. if (bytenr == 0) {
  4797. em->block_start = EXTENT_MAP_HOLE;
  4798. goto insert;
  4799. }
  4800. if (compress_type != BTRFS_COMPRESS_NONE) {
  4801. set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
  4802. em->compress_type = compress_type;
  4803. em->block_start = bytenr;
  4804. em->block_len = em->orig_block_len;
  4805. } else {
  4806. bytenr += btrfs_file_extent_offset(leaf, item);
  4807. em->block_start = bytenr;
  4808. em->block_len = em->len;
  4809. if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
  4810. set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
  4811. }
  4812. goto insert;
  4813. } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
  4814. unsigned long ptr;
  4815. char *map;
  4816. size_t size;
  4817. size_t extent_offset;
  4818. size_t copy_size;
  4819. em->block_start = EXTENT_MAP_INLINE;
  4820. if (!page || create) {
  4821. em->start = extent_start;
  4822. em->len = extent_end - extent_start;
  4823. goto out;
  4824. }
  4825. size = btrfs_file_extent_inline_len(leaf, item);
  4826. extent_offset = page_offset(page) + pg_offset - extent_start;
  4827. copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
  4828. size - extent_offset);
  4829. em->start = extent_start + extent_offset;
  4830. em->len = (copy_size + root->sectorsize - 1) &
  4831. ~((u64)root->sectorsize - 1);
  4832. em->orig_block_len = em->len;
  4833. em->orig_start = em->start;
  4834. if (compress_type) {
  4835. set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
  4836. em->compress_type = compress_type;
  4837. }
  4838. ptr = btrfs_file_extent_inline_start(item) + extent_offset;
  4839. if (create == 0 && !PageUptodate(page)) {
  4840. if (btrfs_file_extent_compression(leaf, item) !=
  4841. BTRFS_COMPRESS_NONE) {
  4842. ret = uncompress_inline(path, inode, page,
  4843. pg_offset,
  4844. extent_offset, item);
  4845. BUG_ON(ret); /* -ENOMEM */
  4846. } else {
  4847. map = kmap(page);
  4848. read_extent_buffer(leaf, map + pg_offset, ptr,
  4849. copy_size);
  4850. if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
  4851. memset(map + pg_offset + copy_size, 0,
  4852. PAGE_CACHE_SIZE - pg_offset -
  4853. copy_size);
  4854. }
  4855. kunmap(page);
  4856. }
  4857. flush_dcache_page(page);
  4858. } else if (create && PageUptodate(page)) {
  4859. BUG();
  4860. if (!trans) {
  4861. kunmap(page);
  4862. free_extent_map(em);
  4863. em = NULL;
  4864. btrfs_release_path(path);
  4865. trans = btrfs_join_transaction(root);
  4866. if (IS_ERR(trans))
  4867. return ERR_CAST(trans);
  4868. goto again;
  4869. }
  4870. map = kmap(page);
  4871. write_extent_buffer(leaf, map + pg_offset, ptr,
  4872. copy_size);
  4873. kunmap(page);
  4874. btrfs_mark_buffer_dirty(leaf);
  4875. }
  4876. set_extent_uptodate(io_tree, em->start,
  4877. extent_map_end(em) - 1, NULL, GFP_NOFS);
  4878. goto insert;
  4879. } else {
  4880. WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
  4881. }
  4882. not_found:
  4883. em->start = start;
  4884. em->orig_start = start;
  4885. em->len = len;
  4886. not_found_em:
  4887. em->block_start = EXTENT_MAP_HOLE;
  4888. set_bit(EXTENT_FLAG_VACANCY, &em->flags);
  4889. insert:
  4890. btrfs_release_path(path);
  4891. if (em->start > start || extent_map_end(em) <= start) {
  4892. printk(KERN_ERR "Btrfs: bad extent! em: [%llu %llu] passed "
  4893. "[%llu %llu]\n", (unsigned long long)em->start,
  4894. (unsigned long long)em->len,
  4895. (unsigned long long)start,
  4896. (unsigned long long)len);
  4897. err = -EIO;
  4898. goto out;
  4899. }
  4900. err = 0;
  4901. write_lock(&em_tree->lock);
  4902. ret = add_extent_mapping(em_tree, em);
  4903. /* it is possible that someone inserted the extent into the tree
  4904. * while we had the lock dropped. It is also possible that
  4905. * an overlapping map exists in the tree
  4906. */
  4907. if (ret == -EEXIST) {
  4908. struct extent_map *existing;
  4909. ret = 0;
  4910. existing = lookup_extent_mapping(em_tree, start, len);
  4911. if (existing && (existing->start > start ||
  4912. existing->start + existing->len <= start)) {
  4913. free_extent_map(existing);
  4914. existing = NULL;
  4915. }
  4916. if (!existing) {
  4917. existing = lookup_extent_mapping(em_tree, em->start,
  4918. em->len);
  4919. if (existing) {
  4920. err = merge_extent_mapping(em_tree, existing,
  4921. em, start,
  4922. root->sectorsize);
  4923. free_extent_map(existing);
  4924. if (err) {
  4925. free_extent_map(em);
  4926. em = NULL;
  4927. }
  4928. } else {
  4929. err = -EIO;
  4930. free_extent_map(em);
  4931. em = NULL;
  4932. }
  4933. } else {
  4934. free_extent_map(em);
  4935. em = existing;
  4936. err = 0;
  4937. }
  4938. }
  4939. write_unlock(&em_tree->lock);
  4940. out:
  4941. if (em)
  4942. trace_btrfs_get_extent(root, em);
  4943. if (path)
  4944. btrfs_free_path(path);
  4945. if (trans) {
  4946. ret = btrfs_end_transaction(trans, root);
  4947. if (!err)
  4948. err = ret;
  4949. }
  4950. if (err) {
  4951. free_extent_map(em);
  4952. return ERR_PTR(err);
  4953. }
  4954. BUG_ON(!em); /* Error is always set */
  4955. return em;
  4956. }
  4957. struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
  4958. size_t pg_offset, u64 start, u64 len,
  4959. int create)
  4960. {
  4961. struct extent_map *em;
  4962. struct extent_map *hole_em = NULL;
  4963. u64 range_start = start;
  4964. u64 end;
  4965. u64 found;
  4966. u64 found_end;
  4967. int err = 0;
  4968. em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
  4969. if (IS_ERR(em))
  4970. return em;
  4971. if (em) {
  4972. /*
  4973. * if our em maps to
  4974. * - a hole or
  4975. * - a pre-alloc extent,
  4976. * there might actually be delalloc bytes behind it.
  4977. */
  4978. if (em->block_start != EXTENT_MAP_HOLE &&
  4979. !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
  4980. return em;
  4981. else
  4982. hole_em = em;
  4983. }
  4984. /* check to see if we've wrapped (len == -1 or similar) */
  4985. end = start + len;
  4986. if (end < start)
  4987. end = (u64)-1;
  4988. else
  4989. end -= 1;
  4990. em = NULL;
  4991. /* ok, we didn't find anything, lets look for delalloc */
  4992. found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
  4993. end, len, EXTENT_DELALLOC, 1);
  4994. found_end = range_start + found;
  4995. if (found_end < range_start)
  4996. found_end = (u64)-1;
  4997. /*
  4998. * we didn't find anything useful, return
  4999. * the original results from get_extent()
  5000. */
  5001. if (range_start > end || found_end <= start) {
  5002. em = hole_em;
  5003. hole_em = NULL;
  5004. goto out;
  5005. }
  5006. /* adjust the range_start to make sure it doesn't
  5007. * go backwards from the start they passed in
  5008. */
  5009. range_start = max(start,range_start);
  5010. found = found_end - range_start;
  5011. if (found > 0) {
  5012. u64 hole_start = start;
  5013. u64 hole_len = len;
  5014. em = alloc_extent_map();
  5015. if (!em) {
  5016. err = -ENOMEM;
  5017. goto out;
  5018. }
  5019. /*
  5020. * when btrfs_get_extent can't find anything it
  5021. * returns one huge hole
  5022. *
  5023. * make sure what it found really fits our range, and
  5024. * adjust to make sure it is based on the start from
  5025. * the caller
  5026. */
  5027. if (hole_em) {
  5028. u64 calc_end = extent_map_end(hole_em);
  5029. if (calc_end <= start || (hole_em->start > end)) {
  5030. free_extent_map(hole_em);
  5031. hole_em = NULL;
  5032. } else {
  5033. hole_start = max(hole_em->start, start);
  5034. hole_len = calc_end - hole_start;
  5035. }
  5036. }
  5037. em->bdev = NULL;
  5038. if (hole_em && range_start > hole_start) {
  5039. /* our hole starts before our delalloc, so we
  5040. * have to return just the parts of the hole
  5041. * that go until the delalloc starts
  5042. */
  5043. em->len = min(hole_len,
  5044. range_start - hole_start);
  5045. em->start = hole_start;
  5046. em->orig_start = hole_start;
  5047. /*
  5048. * don't adjust block start at all,
  5049. * it is fixed at EXTENT_MAP_HOLE
  5050. */
  5051. em->block_start = hole_em->block_start;
  5052. em->block_len = hole_len;
  5053. if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
  5054. set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
  5055. } else {
  5056. em->start = range_start;
  5057. em->len = found;
  5058. em->orig_start = range_start;
  5059. em->block_start = EXTENT_MAP_DELALLOC;
  5060. em->block_len = found;
  5061. }
  5062. } else if (hole_em) {
  5063. return hole_em;
  5064. }
  5065. out:
  5066. free_extent_map(hole_em);
  5067. if (err) {
  5068. free_extent_map(em);
  5069. return ERR_PTR(err);
  5070. }
  5071. return em;
  5072. }
  5073. static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
  5074. u64 start, u64 len)
  5075. {
  5076. struct btrfs_root *root = BTRFS_I(inode)->root;
  5077. struct btrfs_trans_handle *trans;
  5078. struct extent_map *em;
  5079. struct btrfs_key ins;
  5080. u64 alloc_hint;
  5081. int ret;
  5082. trans = btrfs_join_transaction(root);
  5083. if (IS_ERR(trans))
  5084. return ERR_CAST(trans);
  5085. trans->block_rsv = &root->fs_info->delalloc_block_rsv;
  5086. alloc_hint = get_extent_allocation_hint(inode, start, len);
  5087. ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
  5088. alloc_hint, &ins, 1);
  5089. if (ret) {
  5090. em = ERR_PTR(ret);
  5091. goto out;
  5092. }
  5093. em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
  5094. ins.offset, ins.offset, 0);
  5095. if (IS_ERR(em))
  5096. goto out;
  5097. ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
  5098. ins.offset, ins.offset, 0);
  5099. if (ret) {
  5100. btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
  5101. em = ERR_PTR(ret);
  5102. }
  5103. out:
  5104. btrfs_end_transaction(trans, root);
  5105. return em;
  5106. }
  5107. /*
  5108. * returns 1 when the nocow is safe, < 1 on error, 0 if the
  5109. * block must be cow'd
  5110. */
  5111. static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
  5112. struct inode *inode, u64 offset, u64 len)
  5113. {
  5114. struct btrfs_path *path;
  5115. int ret;
  5116. struct extent_buffer *leaf;
  5117. struct btrfs_root *root = BTRFS_I(inode)->root;
  5118. struct btrfs_file_extent_item *fi;
  5119. struct btrfs_key key;
  5120. u64 disk_bytenr;
  5121. u64 backref_offset;
  5122. u64 extent_end;
  5123. u64 num_bytes;
  5124. int slot;
  5125. int found_type;
  5126. path = btrfs_alloc_path();
  5127. if (!path)
  5128. return -ENOMEM;
  5129. ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
  5130. offset, 0);
  5131. if (ret < 0)
  5132. goto out;
  5133. slot = path->slots[0];
  5134. if (ret == 1) {
  5135. if (slot == 0) {
  5136. /* can't find the item, must cow */
  5137. ret = 0;
  5138. goto out;
  5139. }
  5140. slot--;
  5141. }
  5142. ret = 0;
  5143. leaf = path->nodes[0];
  5144. btrfs_item_key_to_cpu(leaf, &key, slot);
  5145. if (key.objectid != btrfs_ino(inode) ||
  5146. key.type != BTRFS_EXTENT_DATA_KEY) {
  5147. /* not our file or wrong item type, must cow */
  5148. goto out;
  5149. }
  5150. if (key.offset > offset) {
  5151. /* Wrong offset, must cow */
  5152. goto out;
  5153. }
  5154. fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
  5155. found_type = btrfs_file_extent_type(leaf, fi);
  5156. if (found_type != BTRFS_FILE_EXTENT_REG &&
  5157. found_type != BTRFS_FILE_EXTENT_PREALLOC) {
  5158. /* not a regular extent, must cow */
  5159. goto out;
  5160. }
  5161. disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
  5162. backref_offset = btrfs_file_extent_offset(leaf, fi);
  5163. extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
  5164. if (extent_end < offset + len) {
  5165. /* extent doesn't include our full range, must cow */
  5166. goto out;
  5167. }
  5168. if (btrfs_extent_readonly(root, disk_bytenr))
  5169. goto out;
  5170. /*
  5171. * look for other files referencing this extent, if we
  5172. * find any we must cow
  5173. */
  5174. if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
  5175. key.offset - backref_offset, disk_bytenr))
  5176. goto out;
  5177. /*
  5178. * adjust disk_bytenr and num_bytes to cover just the bytes
  5179. * in this extent we are about to write. If there
  5180. * are any csums in that range we have to cow in order
  5181. * to keep the csums correct
  5182. */
  5183. disk_bytenr += backref_offset;
  5184. disk_bytenr += offset - key.offset;
  5185. num_bytes = min(offset + len, extent_end) - offset;
  5186. if (csum_exist_in_range(root, disk_bytenr, num_bytes))
  5187. goto out;
  5188. /*
  5189. * all of the above have passed, it is safe to overwrite this extent
  5190. * without cow
  5191. */
  5192. ret = 1;
  5193. out:
  5194. btrfs_free_path(path);
  5195. return ret;
  5196. }
  5197. static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
  5198. struct extent_state **cached_state, int writing)
  5199. {
  5200. struct btrfs_ordered_extent *ordered;
  5201. int ret = 0;
  5202. while (1) {
  5203. lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
  5204. 0, cached_state);
  5205. /*
  5206. * We're concerned with the entire range that we're going to be
  5207. * doing DIO to, so we need to make sure theres no ordered
  5208. * extents in this range.
  5209. */
  5210. ordered = btrfs_lookup_ordered_range(inode, lockstart,
  5211. lockend - lockstart + 1);
  5212. /*
  5213. * We need to make sure there are no buffered pages in this
  5214. * range either, we could have raced between the invalidate in
  5215. * generic_file_direct_write and locking the extent. The
  5216. * invalidate needs to happen so that reads after a write do not
  5217. * get stale data.
  5218. */
  5219. if (!ordered && (!writing ||
  5220. !test_range_bit(&BTRFS_I(inode)->io_tree,
  5221. lockstart, lockend, EXTENT_UPTODATE, 0,
  5222. *cached_state)))
  5223. break;
  5224. unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
  5225. cached_state, GFP_NOFS);
  5226. if (ordered) {
  5227. btrfs_start_ordered_extent(inode, ordered, 1);
  5228. btrfs_put_ordered_extent(ordered);
  5229. } else {
  5230. /* Screw you mmap */
  5231. ret = filemap_write_and_wait_range(inode->i_mapping,
  5232. lockstart,
  5233. lockend);
  5234. if (ret)
  5235. break;
  5236. /*
  5237. * If we found a page that couldn't be invalidated just
  5238. * fall back to buffered.
  5239. */
  5240. ret = invalidate_inode_pages2_range(inode->i_mapping,
  5241. lockstart >> PAGE_CACHE_SHIFT,
  5242. lockend >> PAGE_CACHE_SHIFT);
  5243. if (ret)
  5244. break;
  5245. }
  5246. cond_resched();
  5247. }
  5248. return ret;
  5249. }
  5250. static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
  5251. u64 len, u64 orig_start,
  5252. u64 block_start, u64 block_len,
  5253. u64 orig_block_len, int type)
  5254. {
  5255. struct extent_map_tree *em_tree;
  5256. struct extent_map *em;
  5257. struct btrfs_root *root = BTRFS_I(inode)->root;
  5258. int ret;
  5259. em_tree = &BTRFS_I(inode)->extent_tree;
  5260. em = alloc_extent_map();
  5261. if (!em)
  5262. return ERR_PTR(-ENOMEM);
  5263. em->start = start;
  5264. em->orig_start = orig_start;
  5265. em->len = len;
  5266. em->block_len = block_len;
  5267. em->block_start = block_start;
  5268. em->bdev = root->fs_info->fs_devices->latest_bdev;
  5269. em->orig_block_len = orig_block_len;
  5270. em->generation = -1;
  5271. set_bit(EXTENT_FLAG_PINNED, &em->flags);
  5272. if (type == BTRFS_ORDERED_PREALLOC)
  5273. set_bit(EXTENT_FLAG_FILLING, &em->flags);
  5274. do {
  5275. btrfs_drop_extent_cache(inode, em->start,
  5276. em->start + em->len - 1, 0);
  5277. write_lock(&em_tree->lock);
  5278. ret = add_extent_mapping(em_tree, em);
  5279. if (!ret)
  5280. list_move(&em->list,
  5281. &em_tree->modified_extents);
  5282. write_unlock(&em_tree->lock);
  5283. } while (ret == -EEXIST);
  5284. if (ret) {
  5285. free_extent_map(em);
  5286. return ERR_PTR(ret);
  5287. }
  5288. return em;
  5289. }
  5290. static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
  5291. struct buffer_head *bh_result, int create)
  5292. {
  5293. struct extent_map *em;
  5294. struct btrfs_root *root = BTRFS_I(inode)->root;
  5295. struct extent_state *cached_state = NULL;
  5296. u64 start = iblock << inode->i_blkbits;
  5297. u64 lockstart, lockend;
  5298. u64 len = bh_result->b_size;
  5299. struct btrfs_trans_handle *trans;
  5300. int unlock_bits = EXTENT_LOCKED;
  5301. int ret;
  5302. if (create) {
  5303. ret = btrfs_delalloc_reserve_space(inode, len);
  5304. if (ret)
  5305. return ret;
  5306. unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY;
  5307. } else {
  5308. len = min_t(u64, len, root->sectorsize);
  5309. }
  5310. lockstart = start;
  5311. lockend = start + len - 1;
  5312. /*
  5313. * If this errors out it's because we couldn't invalidate pagecache for
  5314. * this range and we need to fallback to buffered.
  5315. */
  5316. if (lock_extent_direct(inode, lockstart, lockend, &cached_state, create))
  5317. return -ENOTBLK;
  5318. if (create) {
  5319. ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
  5320. lockend, EXTENT_DELALLOC, NULL,
  5321. &cached_state, GFP_NOFS);
  5322. if (ret)
  5323. goto unlock_err;
  5324. }
  5325. em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
  5326. if (IS_ERR(em)) {
  5327. ret = PTR_ERR(em);
  5328. goto unlock_err;
  5329. }
  5330. /*
  5331. * Ok for INLINE and COMPRESSED extents we need to fallback on buffered
  5332. * io. INLINE is special, and we could probably kludge it in here, but
  5333. * it's still buffered so for safety lets just fall back to the generic
  5334. * buffered path.
  5335. *
  5336. * For COMPRESSED we _have_ to read the entire extent in so we can
  5337. * decompress it, so there will be buffering required no matter what we
  5338. * do, so go ahead and fallback to buffered.
  5339. *
  5340. * We return -ENOTBLK because thats what makes DIO go ahead and go back
  5341. * to buffered IO. Don't blame me, this is the price we pay for using
  5342. * the generic code.
  5343. */
  5344. if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||
  5345. em->block_start == EXTENT_MAP_INLINE) {
  5346. free_extent_map(em);
  5347. ret = -ENOTBLK;
  5348. goto unlock_err;
  5349. }
  5350. /* Just a good old fashioned hole, return */
  5351. if (!create && (em->block_start == EXTENT_MAP_HOLE ||
  5352. test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
  5353. free_extent_map(em);
  5354. ret = 0;
  5355. goto unlock_err;
  5356. }
  5357. /*
  5358. * We don't allocate a new extent in the following cases
  5359. *
  5360. * 1) The inode is marked as NODATACOW. In this case we'll just use the
  5361. * existing extent.
  5362. * 2) The extent is marked as PREALLOC. We're good to go here and can
  5363. * just use the extent.
  5364. *
  5365. */
  5366. if (!create) {
  5367. len = min(len, em->len - (start - em->start));
  5368. lockstart = start + len;
  5369. goto unlock;
  5370. }
  5371. if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
  5372. ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
  5373. em->block_start != EXTENT_MAP_HOLE)) {
  5374. int type;
  5375. int ret;
  5376. u64 block_start;
  5377. if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
  5378. type = BTRFS_ORDERED_PREALLOC;
  5379. else
  5380. type = BTRFS_ORDERED_NOCOW;
  5381. len = min(len, em->len - (start - em->start));
  5382. block_start = em->block_start + (start - em->start);
  5383. /*
  5384. * we're not going to log anything, but we do need
  5385. * to make sure the current transaction stays open
  5386. * while we look for nocow cross refs
  5387. */
  5388. trans = btrfs_join_transaction(root);
  5389. if (IS_ERR(trans))
  5390. goto must_cow;
  5391. if (can_nocow_odirect(trans, inode, start, len) == 1) {
  5392. u64 orig_start = em->orig_start;
  5393. u64 orig_block_len = em->orig_block_len;
  5394. if (type == BTRFS_ORDERED_PREALLOC) {
  5395. free_extent_map(em);
  5396. em = create_pinned_em(inode, start, len,
  5397. orig_start,
  5398. block_start, len,
  5399. orig_block_len, type);
  5400. if (IS_ERR(em)) {
  5401. btrfs_end_transaction(trans, root);
  5402. goto unlock_err;
  5403. }
  5404. }
  5405. ret = btrfs_add_ordered_extent_dio(inode, start,
  5406. block_start, len, len, type);
  5407. btrfs_end_transaction(trans, root);
  5408. if (ret) {
  5409. free_extent_map(em);
  5410. goto unlock_err;
  5411. }
  5412. goto unlock;
  5413. }
  5414. btrfs_end_transaction(trans, root);
  5415. }
  5416. must_cow:
  5417. /*
  5418. * this will cow the extent, reset the len in case we changed
  5419. * it above
  5420. */
  5421. len = bh_result->b_size;
  5422. free_extent_map(em);
  5423. em = btrfs_new_extent_direct(inode, start, len);
  5424. if (IS_ERR(em)) {
  5425. ret = PTR_ERR(em);
  5426. goto unlock_err;
  5427. }
  5428. len = min(len, em->len - (start - em->start));
  5429. unlock:
  5430. bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
  5431. inode->i_blkbits;
  5432. bh_result->b_size = len;
  5433. bh_result->b_bdev = em->bdev;
  5434. set_buffer_mapped(bh_result);
  5435. if (create) {
  5436. if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
  5437. set_buffer_new(bh_result);
  5438. /*
  5439. * Need to update the i_size under the extent lock so buffered
  5440. * readers will get the updated i_size when we unlock.
  5441. */
  5442. if (start + len > i_size_read(inode))
  5443. i_size_write(inode, start + len);
  5444. }
  5445. /*
  5446. * In the case of write we need to clear and unlock the entire range,
  5447. * in the case of read we need to unlock only the end area that we
  5448. * aren't using if there is any left over space.
  5449. */
  5450. if (lockstart < lockend) {
  5451. if (create && len < lockend - lockstart) {
  5452. clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
  5453. lockstart + len - 1,
  5454. unlock_bits | EXTENT_DEFRAG, 1, 0,
  5455. &cached_state, GFP_NOFS);
  5456. /*
  5457. * Beside unlock, we also need to cleanup reserved space
  5458. * for the left range by attaching EXTENT_DO_ACCOUNTING.
  5459. */
  5460. clear_extent_bit(&BTRFS_I(inode)->io_tree,
  5461. lockstart + len, lockend,
  5462. unlock_bits | EXTENT_DO_ACCOUNTING |
  5463. EXTENT_DEFRAG, 1, 0, NULL, GFP_NOFS);
  5464. } else {
  5465. clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
  5466. lockend, unlock_bits, 1, 0,
  5467. &cached_state, GFP_NOFS);
  5468. }
  5469. } else {
  5470. free_extent_state(cached_state);
  5471. }
  5472. free_extent_map(em);
  5473. return 0;
  5474. unlock_err:
  5475. if (create)
  5476. unlock_bits |= EXTENT_DO_ACCOUNTING;
  5477. clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
  5478. unlock_bits, 1, 0, &cached_state, GFP_NOFS);
  5479. return ret;
  5480. }
  5481. struct btrfs_dio_private {
  5482. struct inode *inode;
  5483. u64 logical_offset;
  5484. u64 disk_bytenr;
  5485. u64 bytes;
  5486. void *private;
  5487. /* number of bios pending for this dio */
  5488. atomic_t pending_bios;
  5489. /* IO errors */
  5490. int errors;
  5491. struct bio *orig_bio;
  5492. };
  5493. static void btrfs_endio_direct_read(struct bio *bio, int err)
  5494. {
  5495. struct btrfs_dio_private *dip = bio->bi_private;
  5496. struct bio_vec *bvec_end = bio->bi_io_vec + bio->bi_vcnt - 1;
  5497. struct bio_vec *bvec = bio->bi_io_vec;
  5498. struct inode *inode = dip->inode;
  5499. struct btrfs_root *root = BTRFS_I(inode)->root;
  5500. u64 start;
  5501. start = dip->logical_offset;
  5502. do {
  5503. if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
  5504. struct page *page = bvec->bv_page;
  5505. char *kaddr;
  5506. u32 csum = ~(u32)0;
  5507. u64 private = ~(u32)0;
  5508. unsigned long flags;
  5509. if (get_state_private(&BTRFS_I(inode)->io_tree,
  5510. start, &private))
  5511. goto failed;
  5512. local_irq_save(flags);
  5513. kaddr = kmap_atomic(page);
  5514. csum = btrfs_csum_data(root, kaddr + bvec->bv_offset,
  5515. csum, bvec->bv_len);
  5516. btrfs_csum_final(csum, (char *)&csum);
  5517. kunmap_atomic(kaddr);
  5518. local_irq_restore(flags);
  5519. flush_dcache_page(bvec->bv_page);
  5520. if (csum != private) {
  5521. failed:
  5522. printk(KERN_ERR "btrfs csum failed ino %llu off"
  5523. " %llu csum %u private %u\n",
  5524. (unsigned long long)btrfs_ino(inode),
  5525. (unsigned long long)start,
  5526. csum, (unsigned)private);
  5527. err = -EIO;
  5528. }
  5529. }
  5530. start += bvec->bv_len;
  5531. bvec++;
  5532. } while (bvec <= bvec_end);
  5533. unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
  5534. dip->logical_offset + dip->bytes - 1);
  5535. bio->bi_private = dip->private;
  5536. kfree(dip);
  5537. /* If we had a csum failure make sure to clear the uptodate flag */
  5538. if (err)
  5539. clear_bit(BIO_UPTODATE, &bio->bi_flags);
  5540. dio_end_io(bio, err);
  5541. }
  5542. static void btrfs_endio_direct_write(struct bio *bio, int err)
  5543. {
  5544. struct btrfs_dio_private *dip = bio->bi_private;
  5545. struct inode *inode = dip->inode;
  5546. struct btrfs_root *root = BTRFS_I(inode)->root;
  5547. struct btrfs_ordered_extent *ordered = NULL;
  5548. u64 ordered_offset = dip->logical_offset;
  5549. u64 ordered_bytes = dip->bytes;
  5550. int ret;
  5551. if (err)
  5552. goto out_done;
  5553. again:
  5554. ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
  5555. &ordered_offset,
  5556. ordered_bytes, !err);
  5557. if (!ret)
  5558. goto out_test;
  5559. ordered->work.func = finish_ordered_fn;
  5560. ordered->work.flags = 0;
  5561. btrfs_queue_worker(&root->fs_info->endio_write_workers,
  5562. &ordered->work);
  5563. out_test:
  5564. /*
  5565. * our bio might span multiple ordered extents. If we haven't
  5566. * completed the accounting for the whole dio, go back and try again
  5567. */
  5568. if (ordered_offset < dip->logical_offset + dip->bytes) {
  5569. ordered_bytes = dip->logical_offset + dip->bytes -
  5570. ordered_offset;
  5571. ordered = NULL;
  5572. goto again;
  5573. }
  5574. out_done:
  5575. bio->bi_private = dip->private;
  5576. kfree(dip);
  5577. /* If we had an error make sure to clear the uptodate flag */
  5578. if (err)
  5579. clear_bit(BIO_UPTODATE, &bio->bi_flags);
  5580. dio_end_io(bio, err);
  5581. }
  5582. static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
  5583. struct bio *bio, int mirror_num,
  5584. unsigned long bio_flags, u64 offset)
  5585. {
  5586. int ret;
  5587. struct btrfs_root *root = BTRFS_I(inode)->root;
  5588. ret = btrfs_csum_one_bio(root, inode, bio, offset, 1);
  5589. BUG_ON(ret); /* -ENOMEM */
  5590. return 0;
  5591. }
  5592. static void btrfs_end_dio_bio(struct bio *bio, int err)
  5593. {
  5594. struct btrfs_dio_private *dip = bio->bi_private;
  5595. if (err) {
  5596. printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
  5597. "sector %#Lx len %u err no %d\n",
  5598. (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
  5599. (unsigned long long)bio->bi_sector, bio->bi_size, err);
  5600. dip->errors = 1;
  5601. /*
  5602. * before atomic variable goto zero, we must make sure
  5603. * dip->errors is perceived to be set.
  5604. */
  5605. smp_mb__before_atomic_dec();
  5606. }
  5607. /* if there are more bios still pending for this dio, just exit */
  5608. if (!atomic_dec_and_test(&dip->pending_bios))
  5609. goto out;
  5610. if (dip->errors)
  5611. bio_io_error(dip->orig_bio);
  5612. else {
  5613. set_bit(BIO_UPTODATE, &dip->orig_bio->bi_flags);
  5614. bio_endio(dip->orig_bio, 0);
  5615. }
  5616. out:
  5617. bio_put(bio);
  5618. }
  5619. static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
  5620. u64 first_sector, gfp_t gfp_flags)
  5621. {
  5622. int nr_vecs = bio_get_nr_vecs(bdev);
  5623. return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags);
  5624. }
  5625. static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
  5626. int rw, u64 file_offset, int skip_sum,
  5627. int async_submit)
  5628. {
  5629. int write = rw & REQ_WRITE;
  5630. struct btrfs_root *root = BTRFS_I(inode)->root;
  5631. int ret;
  5632. if (async_submit)
  5633. async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
  5634. bio_get(bio);
  5635. if (!write) {
  5636. ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
  5637. if (ret)
  5638. goto err;
  5639. }
  5640. if (skip_sum)
  5641. goto map;
  5642. if (write && async_submit) {
  5643. ret = btrfs_wq_submit_bio(root->fs_info,
  5644. inode, rw, bio, 0, 0,
  5645. file_offset,
  5646. __btrfs_submit_bio_start_direct_io,
  5647. __btrfs_submit_bio_done);
  5648. goto err;
  5649. } else if (write) {
  5650. /*
  5651. * If we aren't doing async submit, calculate the csum of the
  5652. * bio now.
  5653. */
  5654. ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
  5655. if (ret)
  5656. goto err;
  5657. } else if (!skip_sum) {
  5658. ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
  5659. if (ret)
  5660. goto err;
  5661. }
  5662. map:
  5663. ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
  5664. err:
  5665. bio_put(bio);
  5666. return ret;
  5667. }
  5668. static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
  5669. int skip_sum)
  5670. {
  5671. struct inode *inode = dip->inode;
  5672. struct btrfs_root *root = BTRFS_I(inode)->root;
  5673. struct bio *bio;
  5674. struct bio *orig_bio = dip->orig_bio;
  5675. struct bio_vec *bvec = orig_bio->bi_io_vec;
  5676. u64 start_sector = orig_bio->bi_sector;
  5677. u64 file_offset = dip->logical_offset;
  5678. u64 submit_len = 0;
  5679. u64 map_length;
  5680. int nr_pages = 0;
  5681. int ret = 0;
  5682. int async_submit = 0;
  5683. map_length = orig_bio->bi_size;
  5684. ret = btrfs_map_block(root->fs_info, READ, start_sector << 9,
  5685. &map_length, NULL, 0);
  5686. if (ret) {
  5687. bio_put(orig_bio);
  5688. return -EIO;
  5689. }
  5690. if (map_length >= orig_bio->bi_size) {
  5691. bio = orig_bio;
  5692. goto submit;
  5693. }
  5694. async_submit = 1;
  5695. bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
  5696. if (!bio)
  5697. return -ENOMEM;
  5698. bio->bi_private = dip;
  5699. bio->bi_end_io = btrfs_end_dio_bio;
  5700. atomic_inc(&dip->pending_bios);
  5701. while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
  5702. if (unlikely(map_length < submit_len + bvec->bv_len ||
  5703. bio_add_page(bio, bvec->bv_page, bvec->bv_len,
  5704. bvec->bv_offset) < bvec->bv_len)) {
  5705. /*
  5706. * inc the count before we submit the bio so
  5707. * we know the end IO handler won't happen before
  5708. * we inc the count. Otherwise, the dip might get freed
  5709. * before we're done setting it up
  5710. */
  5711. atomic_inc(&dip->pending_bios);
  5712. ret = __btrfs_submit_dio_bio(bio, inode, rw,
  5713. file_offset, skip_sum,
  5714. async_submit);
  5715. if (ret) {
  5716. bio_put(bio);
  5717. atomic_dec(&dip->pending_bios);
  5718. goto out_err;
  5719. }
  5720. start_sector += submit_len >> 9;
  5721. file_offset += submit_len;
  5722. submit_len = 0;
  5723. nr_pages = 0;
  5724. bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
  5725. start_sector, GFP_NOFS);
  5726. if (!bio)
  5727. goto out_err;
  5728. bio->bi_private = dip;
  5729. bio->bi_end_io = btrfs_end_dio_bio;
  5730. map_length = orig_bio->bi_size;
  5731. ret = btrfs_map_block(root->fs_info, READ,
  5732. start_sector << 9,
  5733. &map_length, NULL, 0);
  5734. if (ret) {
  5735. bio_put(bio);
  5736. goto out_err;
  5737. }
  5738. } else {
  5739. submit_len += bvec->bv_len;
  5740. nr_pages ++;
  5741. bvec++;
  5742. }
  5743. }
  5744. submit:
  5745. ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
  5746. async_submit);
  5747. if (!ret)
  5748. return 0;
  5749. bio_put(bio);
  5750. out_err:
  5751. dip->errors = 1;
  5752. /*
  5753. * before atomic variable goto zero, we must
  5754. * make sure dip->errors is perceived to be set.
  5755. */
  5756. smp_mb__before_atomic_dec();
  5757. if (atomic_dec_and_test(&dip->pending_bios))
  5758. bio_io_error(dip->orig_bio);
  5759. /* bio_end_io() will handle error, so we needn't return it */
  5760. return 0;
  5761. }
  5762. static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
  5763. loff_t file_offset)
  5764. {
  5765. struct btrfs_root *root = BTRFS_I(inode)->root;
  5766. struct btrfs_dio_private *dip;
  5767. struct bio_vec *bvec = bio->bi_io_vec;
  5768. int skip_sum;
  5769. int write = rw & REQ_WRITE;
  5770. int ret = 0;
  5771. skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
  5772. dip = kmalloc(sizeof(*dip), GFP_NOFS);
  5773. if (!dip) {
  5774. ret = -ENOMEM;
  5775. goto free_ordered;
  5776. }
  5777. dip->private = bio->bi_private;
  5778. dip->inode = inode;
  5779. dip->logical_offset = file_offset;
  5780. dip->bytes = 0;
  5781. do {
  5782. dip->bytes += bvec->bv_len;
  5783. bvec++;
  5784. } while (bvec <= (bio->bi_io_vec + bio->bi_vcnt - 1));
  5785. dip->disk_bytenr = (u64)bio->bi_sector << 9;
  5786. bio->bi_private = dip;
  5787. dip->errors = 0;
  5788. dip->orig_bio = bio;
  5789. atomic_set(&dip->pending_bios, 0);
  5790. if (write)
  5791. bio->bi_end_io = btrfs_endio_direct_write;
  5792. else
  5793. bio->bi_end_io = btrfs_endio_direct_read;
  5794. ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
  5795. if (!ret)
  5796. return;
  5797. free_ordered:
  5798. /*
  5799. * If this is a write, we need to clean up the reserved space and kill
  5800. * the ordered extent.
  5801. */
  5802. if (write) {
  5803. struct btrfs_ordered_extent *ordered;
  5804. ordered = btrfs_lookup_ordered_extent(inode, file_offset);
  5805. if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
  5806. !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
  5807. btrfs_free_reserved_extent(root, ordered->start,
  5808. ordered->disk_len);
  5809. btrfs_put_ordered_extent(ordered);
  5810. btrfs_put_ordered_extent(ordered);
  5811. }
  5812. bio_endio(bio, ret);
  5813. }
  5814. static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
  5815. const struct iovec *iov, loff_t offset,
  5816. unsigned long nr_segs)
  5817. {
  5818. int seg;
  5819. int i;
  5820. size_t size;
  5821. unsigned long addr;
  5822. unsigned blocksize_mask = root->sectorsize - 1;
  5823. ssize_t retval = -EINVAL;
  5824. loff_t end = offset;
  5825. if (offset & blocksize_mask)
  5826. goto out;
  5827. /* Check the memory alignment. Blocks cannot straddle pages */
  5828. for (seg = 0; seg < nr_segs; seg++) {
  5829. addr = (unsigned long)iov[seg].iov_base;
  5830. size = iov[seg].iov_len;
  5831. end += size;
  5832. if ((addr & blocksize_mask) || (size & blocksize_mask))
  5833. goto out;
  5834. /* If this is a write we don't need to check anymore */
  5835. if (rw & WRITE)
  5836. continue;
  5837. /*
  5838. * Check to make sure we don't have duplicate iov_base's in this
  5839. * iovec, if so return EINVAL, otherwise we'll get csum errors
  5840. * when reading back.
  5841. */
  5842. for (i = seg + 1; i < nr_segs; i++) {
  5843. if (iov[seg].iov_base == iov[i].iov_base)
  5844. goto out;
  5845. }
  5846. }
  5847. retval = 0;
  5848. out:
  5849. return retval;
  5850. }
  5851. static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
  5852. const struct iovec *iov, loff_t offset,
  5853. unsigned long nr_segs)
  5854. {
  5855. struct file *file = iocb->ki_filp;
  5856. struct inode *inode = file->f_mapping->host;
  5857. if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
  5858. offset, nr_segs))
  5859. return 0;
  5860. return __blockdev_direct_IO(rw, iocb, inode,
  5861. BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
  5862. iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
  5863. btrfs_submit_direct, 0);
  5864. }
  5865. #define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC)
  5866. static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
  5867. __u64 start, __u64 len)
  5868. {
  5869. int ret;
  5870. ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
  5871. if (ret)
  5872. return ret;
  5873. return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
  5874. }
  5875. int btrfs_readpage(struct file *file, struct page *page)
  5876. {
  5877. struct extent_io_tree *tree;
  5878. tree = &BTRFS_I(page->mapping->host)->io_tree;
  5879. return extent_read_full_page(tree, page, btrfs_get_extent, 0);
  5880. }
  5881. static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
  5882. {
  5883. struct extent_io_tree *tree;
  5884. if (current->flags & PF_MEMALLOC) {
  5885. redirty_page_for_writepage(wbc, page);
  5886. unlock_page(page);
  5887. return 0;
  5888. }
  5889. tree = &BTRFS_I(page->mapping->host)->io_tree;
  5890. return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
  5891. }
  5892. int btrfs_writepages(struct address_space *mapping,
  5893. struct writeback_control *wbc)
  5894. {
  5895. struct extent_io_tree *tree;
  5896. tree = &BTRFS_I(mapping->host)->io_tree;
  5897. return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
  5898. }
  5899. static int
  5900. btrfs_readpages(struct file *file, struct address_space *mapping,
  5901. struct list_head *pages, unsigned nr_pages)
  5902. {
  5903. struct extent_io_tree *tree;
  5904. tree = &BTRFS_I(mapping->host)->io_tree;
  5905. return extent_readpages(tree, mapping, pages, nr_pages,
  5906. btrfs_get_extent);
  5907. }
  5908. static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
  5909. {
  5910. struct extent_io_tree *tree;
  5911. struct extent_map_tree *map;
  5912. int ret;
  5913. tree = &BTRFS_I(page->mapping->host)->io_tree;
  5914. map = &BTRFS_I(page->mapping->host)->extent_tree;
  5915. ret = try_release_extent_mapping(map, tree, page, gfp_flags);
  5916. if (ret == 1) {
  5917. ClearPagePrivate(page);
  5918. set_page_private(page, 0);
  5919. page_cache_release(page);
  5920. }
  5921. return ret;
  5922. }
  5923. static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
  5924. {
  5925. if (PageWriteback(page) || PageDirty(page))
  5926. return 0;
  5927. return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
  5928. }
  5929. static void btrfs_invalidatepage(struct page *page, unsigned long offset)
  5930. {
  5931. struct inode *inode = page->mapping->host;
  5932. struct extent_io_tree *tree;
  5933. struct btrfs_ordered_extent *ordered;
  5934. struct extent_state *cached_state = NULL;
  5935. u64 page_start = page_offset(page);
  5936. u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
  5937. /*
  5938. * we have the page locked, so new writeback can't start,
  5939. * and the dirty bit won't be cleared while we are here.
  5940. *
  5941. * Wait for IO on this page so that we can safely clear
  5942. * the PagePrivate2 bit and do ordered accounting
  5943. */
  5944. wait_on_page_writeback(page);
  5945. tree = &BTRFS_I(inode)->io_tree;
  5946. if (offset) {
  5947. btrfs_releasepage(page, GFP_NOFS);
  5948. return;
  5949. }
  5950. lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
  5951. ordered = btrfs_lookup_ordered_extent(inode,
  5952. page_offset(page));
  5953. if (ordered) {
  5954. /*
  5955. * IO on this page will never be started, so we need
  5956. * to account for any ordered extents now
  5957. */
  5958. clear_extent_bit(tree, page_start, page_end,
  5959. EXTENT_DIRTY | EXTENT_DELALLOC |
  5960. EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
  5961. EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
  5962. /*
  5963. * whoever cleared the private bit is responsible
  5964. * for the finish_ordered_io
  5965. */
  5966. if (TestClearPagePrivate2(page) &&
  5967. btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
  5968. PAGE_CACHE_SIZE, 1)) {
  5969. btrfs_finish_ordered_io(ordered);
  5970. }
  5971. btrfs_put_ordered_extent(ordered);
  5972. cached_state = NULL;
  5973. lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
  5974. }
  5975. clear_extent_bit(tree, page_start, page_end,
  5976. EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
  5977. EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
  5978. &cached_state, GFP_NOFS);
  5979. __btrfs_releasepage(page, GFP_NOFS);
  5980. ClearPageChecked(page);
  5981. if (PagePrivate(page)) {
  5982. ClearPagePrivate(page);
  5983. set_page_private(page, 0);
  5984. page_cache_release(page);
  5985. }
  5986. }
  5987. /*
  5988. * btrfs_page_mkwrite() is not allowed to change the file size as it gets
  5989. * called from a page fault handler when a page is first dirtied. Hence we must
  5990. * be careful to check for EOF conditions here. We set the page up correctly
  5991. * for a written page which means we get ENOSPC checking when writing into
  5992. * holes and correct delalloc and unwritten extent mapping on filesystems that
  5993. * support these features.
  5994. *
  5995. * We are not allowed to take the i_mutex here so we have to play games to
  5996. * protect against truncate races as the page could now be beyond EOF. Because
  5997. * vmtruncate() writes the inode size before removing pages, once we have the
  5998. * page lock we can determine safely if the page is beyond EOF. If it is not
  5999. * beyond EOF, then the page is guaranteed safe against truncation until we
  6000. * unlock the page.
  6001. */
  6002. int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
  6003. {
  6004. struct page *page = vmf->page;
  6005. struct inode *inode = fdentry(vma->vm_file)->d_inode;
  6006. struct btrfs_root *root = BTRFS_I(inode)->root;
  6007. struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
  6008. struct btrfs_ordered_extent *ordered;
  6009. struct extent_state *cached_state = NULL;
  6010. char *kaddr;
  6011. unsigned long zero_start;
  6012. loff_t size;
  6013. int ret;
  6014. int reserved = 0;
  6015. u64 page_start;
  6016. u64 page_end;
  6017. sb_start_pagefault(inode->i_sb);
  6018. ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
  6019. if (!ret) {
  6020. ret = file_update_time(vma->vm_file);
  6021. reserved = 1;
  6022. }
  6023. if (ret) {
  6024. if (ret == -ENOMEM)
  6025. ret = VM_FAULT_OOM;
  6026. else /* -ENOSPC, -EIO, etc */
  6027. ret = VM_FAULT_SIGBUS;
  6028. if (reserved)
  6029. goto out;
  6030. goto out_noreserve;
  6031. }
  6032. ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
  6033. again:
  6034. lock_page(page);
  6035. size = i_size_read(inode);
  6036. page_start = page_offset(page);
  6037. page_end = page_start + PAGE_CACHE_SIZE - 1;
  6038. if ((page->mapping != inode->i_mapping) ||
  6039. (page_start >= size)) {
  6040. /* page got truncated out from underneath us */
  6041. goto out_unlock;
  6042. }
  6043. wait_on_page_writeback(page);
  6044. lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
  6045. set_page_extent_mapped(page);
  6046. /*
  6047. * we can't set the delalloc bits if there are pending ordered
  6048. * extents. Drop our locks and wait for them to finish
  6049. */
  6050. ordered = btrfs_lookup_ordered_extent(inode, page_start);
  6051. if (ordered) {
  6052. unlock_extent_cached(io_tree, page_start, page_end,
  6053. &cached_state, GFP_NOFS);
  6054. unlock_page(page);
  6055. btrfs_start_ordered_extent(inode, ordered, 1);
  6056. btrfs_put_ordered_extent(ordered);
  6057. goto again;
  6058. }
  6059. /*
  6060. * XXX - page_mkwrite gets called every time the page is dirtied, even
  6061. * if it was already dirty, so for space accounting reasons we need to
  6062. * clear any delalloc bits for the range we are fixing to save. There
  6063. * is probably a better way to do this, but for now keep consistent with
  6064. * prepare_pages in the normal write path.
  6065. */
  6066. clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
  6067. EXTENT_DIRTY | EXTENT_DELALLOC |
  6068. EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
  6069. 0, 0, &cached_state, GFP_NOFS);
  6070. ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
  6071. &cached_state);
  6072. if (ret) {
  6073. unlock_extent_cached(io_tree, page_start, page_end,
  6074. &cached_state, GFP_NOFS);
  6075. ret = VM_FAULT_SIGBUS;
  6076. goto out_unlock;
  6077. }
  6078. ret = 0;
  6079. /* page is wholly or partially inside EOF */
  6080. if (page_start + PAGE_CACHE_SIZE > size)
  6081. zero_start = size & ~PAGE_CACHE_MASK;
  6082. else
  6083. zero_start = PAGE_CACHE_SIZE;
  6084. if (zero_start != PAGE_CACHE_SIZE) {
  6085. kaddr = kmap(page);
  6086. memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
  6087. flush_dcache_page(page);
  6088. kunmap(page);
  6089. }
  6090. ClearPageChecked(page);
  6091. set_page_dirty(page);
  6092. SetPageUptodate(page);
  6093. BTRFS_I(inode)->last_trans = root->fs_info->generation;
  6094. BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
  6095. BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
  6096. unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
  6097. out_unlock:
  6098. if (!ret) {
  6099. sb_end_pagefault(inode->i_sb);
  6100. return VM_FAULT_LOCKED;
  6101. }
  6102. unlock_page(page);
  6103. out:
  6104. btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
  6105. out_noreserve:
  6106. sb_end_pagefault(inode->i_sb);
  6107. return ret;
  6108. }
  6109. static int btrfs_truncate(struct inode *inode)
  6110. {
  6111. struct btrfs_root *root = BTRFS_I(inode)->root;
  6112. struct btrfs_block_rsv *rsv;
  6113. int ret;
  6114. int err = 0;
  6115. struct btrfs_trans_handle *trans;
  6116. u64 mask = root->sectorsize - 1;
  6117. u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
  6118. ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
  6119. if (ret)
  6120. return ret;
  6121. btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
  6122. btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
  6123. /*
  6124. * Yes ladies and gentelment, this is indeed ugly. The fact is we have
  6125. * 3 things going on here
  6126. *
  6127. * 1) We need to reserve space for our orphan item and the space to
  6128. * delete our orphan item. Lord knows we don't want to have a dangling
  6129. * orphan item because we didn't reserve space to remove it.
  6130. *
  6131. * 2) We need to reserve space to update our inode.
  6132. *
  6133. * 3) We need to have something to cache all the space that is going to
  6134. * be free'd up by the truncate operation, but also have some slack
  6135. * space reserved in case it uses space during the truncate (thank you
  6136. * very much snapshotting).
  6137. *
  6138. * And we need these to all be seperate. The fact is we can use alot of
  6139. * space doing the truncate, and we have no earthly idea how much space
  6140. * we will use, so we need the truncate reservation to be seperate so it
  6141. * doesn't end up using space reserved for updating the inode or
  6142. * removing the orphan item. We also need to be able to stop the
  6143. * transaction and start a new one, which means we need to be able to
  6144. * update the inode several times, and we have no idea of knowing how
  6145. * many times that will be, so we can't just reserve 1 item for the
  6146. * entirety of the opration, so that has to be done seperately as well.
  6147. * Then there is the orphan item, which does indeed need to be held on
  6148. * to for the whole operation, and we need nobody to touch this reserved
  6149. * space except the orphan code.
  6150. *
  6151. * So that leaves us with
  6152. *
  6153. * 1) root->orphan_block_rsv - for the orphan deletion.
  6154. * 2) rsv - for the truncate reservation, which we will steal from the
  6155. * transaction reservation.
  6156. * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
  6157. * updating the inode.
  6158. */
  6159. rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
  6160. if (!rsv)
  6161. return -ENOMEM;
  6162. rsv->size = min_size;
  6163. rsv->failfast = 1;
  6164. /*
  6165. * 1 for the truncate slack space
  6166. * 1 for updating the inode.
  6167. */
  6168. trans = btrfs_start_transaction(root, 2);
  6169. if (IS_ERR(trans)) {
  6170. err = PTR_ERR(trans);
  6171. goto out;
  6172. }
  6173. /* Migrate the slack space for the truncate to our reserve */
  6174. ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
  6175. min_size);
  6176. BUG_ON(ret);
  6177. /*
  6178. * setattr is responsible for setting the ordered_data_close flag,
  6179. * but that is only tested during the last file release. That
  6180. * could happen well after the next commit, leaving a great big
  6181. * window where new writes may get lost if someone chooses to write
  6182. * to this file after truncating to zero
  6183. *
  6184. * The inode doesn't have any dirty data here, and so if we commit
  6185. * this is a noop. If someone immediately starts writing to the inode
  6186. * it is very likely we'll catch some of their writes in this
  6187. * transaction, and the commit will find this file on the ordered
  6188. * data list with good things to send down.
  6189. *
  6190. * This is a best effort solution, there is still a window where
  6191. * using truncate to replace the contents of the file will
  6192. * end up with a zero length file after a crash.
  6193. */
  6194. if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
  6195. &BTRFS_I(inode)->runtime_flags))
  6196. btrfs_add_ordered_operation(trans, root, inode);
  6197. /*
  6198. * So if we truncate and then write and fsync we normally would just
  6199. * write the extents that changed, which is a problem if we need to
  6200. * first truncate that entire inode. So set this flag so we write out
  6201. * all of the extents in the inode to the sync log so we're completely
  6202. * safe.
  6203. */
  6204. set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
  6205. trans->block_rsv = rsv;
  6206. while (1) {
  6207. ret = btrfs_truncate_inode_items(trans, root, inode,
  6208. inode->i_size,
  6209. BTRFS_EXTENT_DATA_KEY);
  6210. if (ret != -ENOSPC) {
  6211. err = ret;
  6212. break;
  6213. }
  6214. trans->block_rsv = &root->fs_info->trans_block_rsv;
  6215. ret = btrfs_update_inode(trans, root, inode);
  6216. if (ret) {
  6217. err = ret;
  6218. break;
  6219. }
  6220. btrfs_end_transaction(trans, root);
  6221. btrfs_btree_balance_dirty(root);
  6222. trans = btrfs_start_transaction(root, 2);
  6223. if (IS_ERR(trans)) {
  6224. ret = err = PTR_ERR(trans);
  6225. trans = NULL;
  6226. break;
  6227. }
  6228. ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
  6229. rsv, min_size);
  6230. BUG_ON(ret); /* shouldn't happen */
  6231. trans->block_rsv = rsv;
  6232. }
  6233. if (ret == 0 && inode->i_nlink > 0) {
  6234. trans->block_rsv = root->orphan_block_rsv;
  6235. ret = btrfs_orphan_del(trans, inode);
  6236. if (ret)
  6237. err = ret;
  6238. }
  6239. if (trans) {
  6240. trans->block_rsv = &root->fs_info->trans_block_rsv;
  6241. ret = btrfs_update_inode(trans, root, inode);
  6242. if (ret && !err)
  6243. err = ret;
  6244. ret = btrfs_end_transaction(trans, root);
  6245. btrfs_btree_balance_dirty(root);
  6246. }
  6247. out:
  6248. btrfs_free_block_rsv(root, rsv);
  6249. if (ret && !err)
  6250. err = ret;
  6251. return err;
  6252. }
  6253. /*
  6254. * create a new subvolume directory/inode (helper for the ioctl).
  6255. */
  6256. int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
  6257. struct btrfs_root *new_root, u64 new_dirid)
  6258. {
  6259. struct inode *inode;
  6260. int err;
  6261. u64 index = 0;
  6262. inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
  6263. new_dirid, new_dirid,
  6264. S_IFDIR | (~current_umask() & S_IRWXUGO),
  6265. &index);
  6266. if (IS_ERR(inode))
  6267. return PTR_ERR(inode);
  6268. inode->i_op = &btrfs_dir_inode_operations;
  6269. inode->i_fop = &btrfs_dir_file_operations;
  6270. set_nlink(inode, 1);
  6271. btrfs_i_size_write(inode, 0);
  6272. err = btrfs_update_inode(trans, new_root, inode);
  6273. iput(inode);
  6274. return err;
  6275. }
  6276. struct inode *btrfs_alloc_inode(struct super_block *sb)
  6277. {
  6278. struct btrfs_inode *ei;
  6279. struct inode *inode;
  6280. ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
  6281. if (!ei)
  6282. return NULL;
  6283. ei->root = NULL;
  6284. ei->generation = 0;
  6285. ei->last_trans = 0;
  6286. ei->last_sub_trans = 0;
  6287. ei->logged_trans = 0;
  6288. ei->delalloc_bytes = 0;
  6289. ei->disk_i_size = 0;
  6290. ei->flags = 0;
  6291. ei->csum_bytes = 0;
  6292. ei->index_cnt = (u64)-1;
  6293. ei->last_unlink_trans = 0;
  6294. ei->last_log_commit = 0;
  6295. spin_lock_init(&ei->lock);
  6296. ei->outstanding_extents = 0;
  6297. ei->reserved_extents = 0;
  6298. ei->runtime_flags = 0;
  6299. ei->force_compress = BTRFS_COMPRESS_NONE;
  6300. ei->delayed_node = NULL;
  6301. inode = &ei->vfs_inode;
  6302. extent_map_tree_init(&ei->extent_tree);
  6303. extent_io_tree_init(&ei->io_tree, &inode->i_data);
  6304. extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
  6305. ei->io_tree.track_uptodate = 1;
  6306. ei->io_failure_tree.track_uptodate = 1;
  6307. atomic_set(&ei->sync_writers, 0);
  6308. mutex_init(&ei->log_mutex);
  6309. mutex_init(&ei->delalloc_mutex);
  6310. btrfs_ordered_inode_tree_init(&ei->ordered_tree);
  6311. INIT_LIST_HEAD(&ei->delalloc_inodes);
  6312. INIT_LIST_HEAD(&ei->ordered_operations);
  6313. RB_CLEAR_NODE(&ei->rb_node);
  6314. return inode;
  6315. }
  6316. static void btrfs_i_callback(struct rcu_head *head)
  6317. {
  6318. struct inode *inode = container_of(head, struct inode, i_rcu);
  6319. kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
  6320. }
  6321. void btrfs_destroy_inode(struct inode *inode)
  6322. {
  6323. struct btrfs_ordered_extent *ordered;
  6324. struct btrfs_root *root = BTRFS_I(inode)->root;
  6325. WARN_ON(!hlist_empty(&inode->i_dentry));
  6326. WARN_ON(inode->i_data.nrpages);
  6327. WARN_ON(BTRFS_I(inode)->outstanding_extents);
  6328. WARN_ON(BTRFS_I(inode)->reserved_extents);
  6329. WARN_ON(BTRFS_I(inode)->delalloc_bytes);
  6330. WARN_ON(BTRFS_I(inode)->csum_bytes);
  6331. /*
  6332. * This can happen where we create an inode, but somebody else also
  6333. * created the same inode and we need to destroy the one we already
  6334. * created.
  6335. */
  6336. if (!root)
  6337. goto free;
  6338. /*
  6339. * Make sure we're properly removed from the ordered operation
  6340. * lists.
  6341. */
  6342. smp_mb();
  6343. if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
  6344. spin_lock(&root->fs_info->ordered_extent_lock);
  6345. list_del_init(&BTRFS_I(inode)->ordered_operations);
  6346. spin_unlock(&root->fs_info->ordered_extent_lock);
  6347. }
  6348. if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
  6349. &BTRFS_I(inode)->runtime_flags)) {
  6350. printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
  6351. (unsigned long long)btrfs_ino(inode));
  6352. atomic_dec(&root->orphan_inodes);
  6353. }
  6354. while (1) {
  6355. ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
  6356. if (!ordered)
  6357. break;
  6358. else {
  6359. printk(KERN_ERR "btrfs found ordered "
  6360. "extent %llu %llu on inode cleanup\n",
  6361. (unsigned long long)ordered->file_offset,
  6362. (unsigned long long)ordered->len);
  6363. btrfs_remove_ordered_extent(inode, ordered);
  6364. btrfs_put_ordered_extent(ordered);
  6365. btrfs_put_ordered_extent(ordered);
  6366. }
  6367. }
  6368. inode_tree_del(inode);
  6369. btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
  6370. free:
  6371. btrfs_remove_delayed_node(inode);
  6372. call_rcu(&inode->i_rcu, btrfs_i_callback);
  6373. }
  6374. int btrfs_drop_inode(struct inode *inode)
  6375. {
  6376. struct btrfs_root *root = BTRFS_I(inode)->root;
  6377. if (btrfs_root_refs(&root->root_item) == 0 &&
  6378. !btrfs_is_free_space_inode(inode))
  6379. return 1;
  6380. else
  6381. return generic_drop_inode(inode);
  6382. }
  6383. static void init_once(void *foo)
  6384. {
  6385. struct btrfs_inode *ei = (struct btrfs_inode *) foo;
  6386. inode_init_once(&ei->vfs_inode);
  6387. }
  6388. void btrfs_destroy_cachep(void)
  6389. {
  6390. /*
  6391. * Make sure all delayed rcu free inodes are flushed before we
  6392. * destroy cache.
  6393. */
  6394. rcu_barrier();
  6395. if (btrfs_inode_cachep)
  6396. kmem_cache_destroy(btrfs_inode_cachep);
  6397. if (btrfs_trans_handle_cachep)
  6398. kmem_cache_destroy(btrfs_trans_handle_cachep);
  6399. if (btrfs_transaction_cachep)
  6400. kmem_cache_destroy(btrfs_transaction_cachep);
  6401. if (btrfs_path_cachep)
  6402. kmem_cache_destroy(btrfs_path_cachep);
  6403. if (btrfs_free_space_cachep)
  6404. kmem_cache_destroy(btrfs_free_space_cachep);
  6405. if (btrfs_delalloc_work_cachep)
  6406. kmem_cache_destroy(btrfs_delalloc_work_cachep);
  6407. }
  6408. int btrfs_init_cachep(void)
  6409. {
  6410. btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
  6411. sizeof(struct btrfs_inode), 0,
  6412. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
  6413. if (!btrfs_inode_cachep)
  6414. goto fail;
  6415. btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
  6416. sizeof(struct btrfs_trans_handle), 0,
  6417. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
  6418. if (!btrfs_trans_handle_cachep)
  6419. goto fail;
  6420. btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
  6421. sizeof(struct btrfs_transaction), 0,
  6422. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
  6423. if (!btrfs_transaction_cachep)
  6424. goto fail;
  6425. btrfs_path_cachep = kmem_cache_create("btrfs_path",
  6426. sizeof(struct btrfs_path), 0,
  6427. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
  6428. if (!btrfs_path_cachep)
  6429. goto fail;
  6430. btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
  6431. sizeof(struct btrfs_free_space), 0,
  6432. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
  6433. if (!btrfs_free_space_cachep)
  6434. goto fail;
  6435. btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
  6436. sizeof(struct btrfs_delalloc_work), 0,
  6437. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
  6438. NULL);
  6439. if (!btrfs_delalloc_work_cachep)
  6440. goto fail;
  6441. return 0;
  6442. fail:
  6443. btrfs_destroy_cachep();
  6444. return -ENOMEM;
  6445. }
  6446. static int btrfs_getattr(struct vfsmount *mnt,
  6447. struct dentry *dentry, struct kstat *stat)
  6448. {
  6449. struct inode *inode = dentry->d_inode;
  6450. u32 blocksize = inode->i_sb->s_blocksize;
  6451. generic_fillattr(inode, stat);
  6452. stat->dev = BTRFS_I(inode)->root->anon_dev;
  6453. stat->blksize = PAGE_CACHE_SIZE;
  6454. stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
  6455. ALIGN(BTRFS_I(inode)->delalloc_bytes, blocksize)) >> 9;
  6456. return 0;
  6457. }
  6458. /*
  6459. * If a file is moved, it will inherit the cow and compression flags of the new
  6460. * directory.
  6461. */
  6462. static void fixup_inode_flags(struct inode *dir, struct inode *inode)
  6463. {
  6464. struct btrfs_inode *b_dir = BTRFS_I(dir);
  6465. struct btrfs_inode *b_inode = BTRFS_I(inode);
  6466. if (b_dir->flags & BTRFS_INODE_NODATACOW)
  6467. b_inode->flags |= BTRFS_INODE_NODATACOW;
  6468. else
  6469. b_inode->flags &= ~BTRFS_INODE_NODATACOW;
  6470. if (b_dir->flags & BTRFS_INODE_COMPRESS) {
  6471. b_inode->flags |= BTRFS_INODE_COMPRESS;
  6472. b_inode->flags &= ~BTRFS_INODE_NOCOMPRESS;
  6473. } else {
  6474. b_inode->flags &= ~(BTRFS_INODE_COMPRESS |
  6475. BTRFS_INODE_NOCOMPRESS);
  6476. }
  6477. }
  6478. static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  6479. struct inode *new_dir, struct dentry *new_dentry)
  6480. {
  6481. struct btrfs_trans_handle *trans;
  6482. struct btrfs_root *root = BTRFS_I(old_dir)->root;
  6483. struct btrfs_root *dest = BTRFS_I(new_dir)->root;
  6484. struct inode *new_inode = new_dentry->d_inode;
  6485. struct inode *old_inode = old_dentry->d_inode;
  6486. struct timespec ctime = CURRENT_TIME;
  6487. u64 index = 0;
  6488. u64 root_objectid;
  6489. int ret;
  6490. u64 old_ino = btrfs_ino(old_inode);
  6491. if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
  6492. return -EPERM;
  6493. /* we only allow rename subvolume link between subvolumes */
  6494. if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
  6495. return -EXDEV;
  6496. if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
  6497. (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
  6498. return -ENOTEMPTY;
  6499. if (S_ISDIR(old_inode->i_mode) && new_inode &&
  6500. new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
  6501. return -ENOTEMPTY;
  6502. /* check for collisions, even if the name isn't there */
  6503. ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
  6504. new_dentry->d_name.name,
  6505. new_dentry->d_name.len);
  6506. if (ret) {
  6507. if (ret == -EEXIST) {
  6508. /* we shouldn't get
  6509. * eexist without a new_inode */
  6510. if (!new_inode) {
  6511. WARN_ON(1);
  6512. return ret;
  6513. }
  6514. } else {
  6515. /* maybe -EOVERFLOW */
  6516. return ret;
  6517. }
  6518. }
  6519. ret = 0;
  6520. /*
  6521. * we're using rename to replace one file with another.
  6522. * and the replacement file is large. Start IO on it now so
  6523. * we don't add too much work to the end of the transaction
  6524. */
  6525. if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
  6526. old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
  6527. filemap_flush(old_inode->i_mapping);
  6528. /* close the racy window with snapshot create/destroy ioctl */
  6529. if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
  6530. down_read(&root->fs_info->subvol_sem);
  6531. /*
  6532. * We want to reserve the absolute worst case amount of items. So if
  6533. * both inodes are subvols and we need to unlink them then that would
  6534. * require 4 item modifications, but if they are both normal inodes it
  6535. * would require 5 item modifications, so we'll assume their normal
  6536. * inodes. So 5 * 2 is 10, plus 1 for the new link, so 11 total items
  6537. * should cover the worst case number of items we'll modify.
  6538. */
  6539. trans = btrfs_start_transaction(root, 20);
  6540. if (IS_ERR(trans)) {
  6541. ret = PTR_ERR(trans);
  6542. goto out_notrans;
  6543. }
  6544. if (dest != root)
  6545. btrfs_record_root_in_trans(trans, dest);
  6546. ret = btrfs_set_inode_index(new_dir, &index);
  6547. if (ret)
  6548. goto out_fail;
  6549. if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
  6550. /* force full log commit if subvolume involved. */
  6551. root->fs_info->last_trans_log_full_commit = trans->transid;
  6552. } else {
  6553. ret = btrfs_insert_inode_ref(trans, dest,
  6554. new_dentry->d_name.name,
  6555. new_dentry->d_name.len,
  6556. old_ino,
  6557. btrfs_ino(new_dir), index);
  6558. if (ret)
  6559. goto out_fail;
  6560. /*
  6561. * this is an ugly little race, but the rename is required
  6562. * to make sure that if we crash, the inode is either at the
  6563. * old name or the new one. pinning the log transaction lets
  6564. * us make sure we don't allow a log commit to come in after
  6565. * we unlink the name but before we add the new name back in.
  6566. */
  6567. btrfs_pin_log_trans(root);
  6568. }
  6569. /*
  6570. * make sure the inode gets flushed if it is replacing
  6571. * something.
  6572. */
  6573. if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
  6574. btrfs_add_ordered_operation(trans, root, old_inode);
  6575. inode_inc_iversion(old_dir);
  6576. inode_inc_iversion(new_dir);
  6577. inode_inc_iversion(old_inode);
  6578. old_dir->i_ctime = old_dir->i_mtime = ctime;
  6579. new_dir->i_ctime = new_dir->i_mtime = ctime;
  6580. old_inode->i_ctime = ctime;
  6581. if (old_dentry->d_parent != new_dentry->d_parent)
  6582. btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
  6583. if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
  6584. root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
  6585. ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
  6586. old_dentry->d_name.name,
  6587. old_dentry->d_name.len);
  6588. } else {
  6589. ret = __btrfs_unlink_inode(trans, root, old_dir,
  6590. old_dentry->d_inode,
  6591. old_dentry->d_name.name,
  6592. old_dentry->d_name.len);
  6593. if (!ret)
  6594. ret = btrfs_update_inode(trans, root, old_inode);
  6595. }
  6596. if (ret) {
  6597. btrfs_abort_transaction(trans, root, ret);
  6598. goto out_fail;
  6599. }
  6600. if (new_inode) {
  6601. inode_inc_iversion(new_inode);
  6602. new_inode->i_ctime = CURRENT_TIME;
  6603. if (unlikely(btrfs_ino(new_inode) ==
  6604. BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
  6605. root_objectid = BTRFS_I(new_inode)->location.objectid;
  6606. ret = btrfs_unlink_subvol(trans, dest, new_dir,
  6607. root_objectid,
  6608. new_dentry->d_name.name,
  6609. new_dentry->d_name.len);
  6610. BUG_ON(new_inode->i_nlink == 0);
  6611. } else {
  6612. ret = btrfs_unlink_inode(trans, dest, new_dir,
  6613. new_dentry->d_inode,
  6614. new_dentry->d_name.name,
  6615. new_dentry->d_name.len);
  6616. }
  6617. if (!ret && new_inode->i_nlink == 0) {
  6618. ret = btrfs_orphan_add(trans, new_dentry->d_inode);
  6619. BUG_ON(ret);
  6620. }
  6621. if (ret) {
  6622. btrfs_abort_transaction(trans, root, ret);
  6623. goto out_fail;
  6624. }
  6625. }
  6626. fixup_inode_flags(new_dir, old_inode);
  6627. ret = btrfs_add_link(trans, new_dir, old_inode,
  6628. new_dentry->d_name.name,
  6629. new_dentry->d_name.len, 0, index);
  6630. if (ret) {
  6631. btrfs_abort_transaction(trans, root, ret);
  6632. goto out_fail;
  6633. }
  6634. if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
  6635. struct dentry *parent = new_dentry->d_parent;
  6636. btrfs_log_new_name(trans, old_inode, old_dir, parent);
  6637. btrfs_end_log_trans(root);
  6638. }
  6639. out_fail:
  6640. btrfs_end_transaction(trans, root);
  6641. out_notrans:
  6642. if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
  6643. up_read(&root->fs_info->subvol_sem);
  6644. return ret;
  6645. }
  6646. static void btrfs_run_delalloc_work(struct btrfs_work *work)
  6647. {
  6648. struct btrfs_delalloc_work *delalloc_work;
  6649. delalloc_work = container_of(work, struct btrfs_delalloc_work,
  6650. work);
  6651. if (delalloc_work->wait)
  6652. btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
  6653. else
  6654. filemap_flush(delalloc_work->inode->i_mapping);
  6655. if (delalloc_work->delay_iput)
  6656. btrfs_add_delayed_iput(delalloc_work->inode);
  6657. else
  6658. iput(delalloc_work->inode);
  6659. complete(&delalloc_work->completion);
  6660. }
  6661. struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
  6662. int wait, int delay_iput)
  6663. {
  6664. struct btrfs_delalloc_work *work;
  6665. work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
  6666. if (!work)
  6667. return NULL;
  6668. init_completion(&work->completion);
  6669. INIT_LIST_HEAD(&work->list);
  6670. work->inode = inode;
  6671. work->wait = wait;
  6672. work->delay_iput = delay_iput;
  6673. work->work.func = btrfs_run_delalloc_work;
  6674. return work;
  6675. }
  6676. void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
  6677. {
  6678. wait_for_completion(&work->completion);
  6679. kmem_cache_free(btrfs_delalloc_work_cachep, work);
  6680. }
  6681. /*
  6682. * some fairly slow code that needs optimization. This walks the list
  6683. * of all the inodes with pending delalloc and forces them to disk.
  6684. */
  6685. int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
  6686. {
  6687. struct btrfs_inode *binode;
  6688. struct inode *inode;
  6689. struct btrfs_delalloc_work *work, *next;
  6690. struct list_head works;
  6691. struct list_head splice;
  6692. int ret = 0;
  6693. if (root->fs_info->sb->s_flags & MS_RDONLY)
  6694. return -EROFS;
  6695. INIT_LIST_HEAD(&works);
  6696. INIT_LIST_HEAD(&splice);
  6697. again:
  6698. spin_lock(&root->fs_info->delalloc_lock);
  6699. list_splice_init(&root->fs_info->delalloc_inodes, &splice);
  6700. while (!list_empty(&splice)) {
  6701. binode = list_entry(splice.next, struct btrfs_inode,
  6702. delalloc_inodes);
  6703. list_del_init(&binode->delalloc_inodes);
  6704. inode = igrab(&binode->vfs_inode);
  6705. if (!inode)
  6706. continue;
  6707. list_add_tail(&binode->delalloc_inodes,
  6708. &root->fs_info->delalloc_inodes);
  6709. spin_unlock(&root->fs_info->delalloc_lock);
  6710. work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
  6711. if (unlikely(!work)) {
  6712. ret = -ENOMEM;
  6713. goto out;
  6714. }
  6715. list_add_tail(&work->list, &works);
  6716. btrfs_queue_worker(&root->fs_info->flush_workers,
  6717. &work->work);
  6718. cond_resched();
  6719. spin_lock(&root->fs_info->delalloc_lock);
  6720. }
  6721. spin_unlock(&root->fs_info->delalloc_lock);
  6722. list_for_each_entry_safe(work, next, &works, list) {
  6723. list_del_init(&work->list);
  6724. btrfs_wait_and_free_delalloc_work(work);
  6725. }
  6726. spin_lock(&root->fs_info->delalloc_lock);
  6727. if (!list_empty(&root->fs_info->delalloc_inodes)) {
  6728. spin_unlock(&root->fs_info->delalloc_lock);
  6729. goto again;
  6730. }
  6731. spin_unlock(&root->fs_info->delalloc_lock);
  6732. /* the filemap_flush will queue IO into the worker threads, but
  6733. * we have to make sure the IO is actually started and that
  6734. * ordered extents get created before we return
  6735. */
  6736. atomic_inc(&root->fs_info->async_submit_draining);
  6737. while (atomic_read(&root->fs_info->nr_async_submits) ||
  6738. atomic_read(&root->fs_info->async_delalloc_pages)) {
  6739. wait_event(root->fs_info->async_submit_wait,
  6740. (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
  6741. atomic_read(&root->fs_info->async_delalloc_pages) == 0));
  6742. }
  6743. atomic_dec(&root->fs_info->async_submit_draining);
  6744. return 0;
  6745. out:
  6746. list_for_each_entry_safe(work, next, &works, list) {
  6747. list_del_init(&work->list);
  6748. btrfs_wait_and_free_delalloc_work(work);
  6749. }
  6750. if (!list_empty_careful(&splice)) {
  6751. spin_lock(&root->fs_info->delalloc_lock);
  6752. list_splice_tail(&splice, &root->fs_info->delalloc_inodes);
  6753. spin_unlock(&root->fs_info->delalloc_lock);
  6754. }
  6755. return ret;
  6756. }
  6757. static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
  6758. const char *symname)
  6759. {
  6760. struct btrfs_trans_handle *trans;
  6761. struct btrfs_root *root = BTRFS_I(dir)->root;
  6762. struct btrfs_path *path;
  6763. struct btrfs_key key;
  6764. struct inode *inode = NULL;
  6765. int err;
  6766. int drop_inode = 0;
  6767. u64 objectid;
  6768. u64 index = 0 ;
  6769. int name_len;
  6770. int datasize;
  6771. unsigned long ptr;
  6772. struct btrfs_file_extent_item *ei;
  6773. struct extent_buffer *leaf;
  6774. name_len = strlen(symname) + 1;
  6775. if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
  6776. return -ENAMETOOLONG;
  6777. /*
  6778. * 2 items for inode item and ref
  6779. * 2 items for dir items
  6780. * 1 item for xattr if selinux is on
  6781. */
  6782. trans = btrfs_start_transaction(root, 5);
  6783. if (IS_ERR(trans))
  6784. return PTR_ERR(trans);
  6785. err = btrfs_find_free_ino(root, &objectid);
  6786. if (err)
  6787. goto out_unlock;
  6788. inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
  6789. dentry->d_name.len, btrfs_ino(dir), objectid,
  6790. S_IFLNK|S_IRWXUGO, &index);
  6791. if (IS_ERR(inode)) {
  6792. err = PTR_ERR(inode);
  6793. goto out_unlock;
  6794. }
  6795. err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
  6796. if (err) {
  6797. drop_inode = 1;
  6798. goto out_unlock;
  6799. }
  6800. /*
  6801. * If the active LSM wants to access the inode during
  6802. * d_instantiate it needs these. Smack checks to see
  6803. * if the filesystem supports xattrs by looking at the
  6804. * ops vector.
  6805. */
  6806. inode->i_fop = &btrfs_file_operations;
  6807. inode->i_op = &btrfs_file_inode_operations;
  6808. err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
  6809. if (err)
  6810. drop_inode = 1;
  6811. else {
  6812. inode->i_mapping->a_ops = &btrfs_aops;
  6813. inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
  6814. BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
  6815. }
  6816. if (drop_inode)
  6817. goto out_unlock;
  6818. path = btrfs_alloc_path();
  6819. if (!path) {
  6820. err = -ENOMEM;
  6821. drop_inode = 1;
  6822. goto out_unlock;
  6823. }
  6824. key.objectid = btrfs_ino(inode);
  6825. key.offset = 0;
  6826. btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
  6827. datasize = btrfs_file_extent_calc_inline_size(name_len);
  6828. err = btrfs_insert_empty_item(trans, root, path, &key,
  6829. datasize);
  6830. if (err) {
  6831. drop_inode = 1;
  6832. btrfs_free_path(path);
  6833. goto out_unlock;
  6834. }
  6835. leaf = path->nodes[0];
  6836. ei = btrfs_item_ptr(leaf, path->slots[0],
  6837. struct btrfs_file_extent_item);
  6838. btrfs_set_file_extent_generation(leaf, ei, trans->transid);
  6839. btrfs_set_file_extent_type(leaf, ei,
  6840. BTRFS_FILE_EXTENT_INLINE);
  6841. btrfs_set_file_extent_encryption(leaf, ei, 0);
  6842. btrfs_set_file_extent_compression(leaf, ei, 0);
  6843. btrfs_set_file_extent_other_encoding(leaf, ei, 0);
  6844. btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
  6845. ptr = btrfs_file_extent_inline_start(ei);
  6846. write_extent_buffer(leaf, symname, ptr, name_len);
  6847. btrfs_mark_buffer_dirty(leaf);
  6848. btrfs_free_path(path);
  6849. inode->i_op = &btrfs_symlink_inode_operations;
  6850. inode->i_mapping->a_ops = &btrfs_symlink_aops;
  6851. inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
  6852. inode_set_bytes(inode, name_len);
  6853. btrfs_i_size_write(inode, name_len - 1);
  6854. err = btrfs_update_inode(trans, root, inode);
  6855. if (err)
  6856. drop_inode = 1;
  6857. out_unlock:
  6858. if (!err)
  6859. d_instantiate(dentry, inode);
  6860. btrfs_end_transaction(trans, root);
  6861. if (drop_inode) {
  6862. inode_dec_link_count(inode);
  6863. iput(inode);
  6864. }
  6865. btrfs_btree_balance_dirty(root);
  6866. return err;
  6867. }
  6868. static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
  6869. u64 start, u64 num_bytes, u64 min_size,
  6870. loff_t actual_len, u64 *alloc_hint,
  6871. struct btrfs_trans_handle *trans)
  6872. {
  6873. struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  6874. struct extent_map *em;
  6875. struct btrfs_root *root = BTRFS_I(inode)->root;
  6876. struct btrfs_key ins;
  6877. u64 cur_offset = start;
  6878. u64 i_size;
  6879. int ret = 0;
  6880. bool own_trans = true;
  6881. if (trans)
  6882. own_trans = false;
  6883. while (num_bytes > 0) {
  6884. if (own_trans) {
  6885. trans = btrfs_start_transaction(root, 3);
  6886. if (IS_ERR(trans)) {
  6887. ret = PTR_ERR(trans);
  6888. break;
  6889. }
  6890. }
  6891. ret = btrfs_reserve_extent(trans, root, num_bytes, min_size,
  6892. 0, *alloc_hint, &ins, 1);
  6893. if (ret) {
  6894. if (own_trans)
  6895. btrfs_end_transaction(trans, root);
  6896. break;
  6897. }
  6898. ret = insert_reserved_file_extent(trans, inode,
  6899. cur_offset, ins.objectid,
  6900. ins.offset, ins.offset,
  6901. ins.offset, 0, 0, 0,
  6902. BTRFS_FILE_EXTENT_PREALLOC);
  6903. if (ret) {
  6904. btrfs_abort_transaction(trans, root, ret);
  6905. if (own_trans)
  6906. btrfs_end_transaction(trans, root);
  6907. break;
  6908. }
  6909. btrfs_drop_extent_cache(inode, cur_offset,
  6910. cur_offset + ins.offset -1, 0);
  6911. em = alloc_extent_map();
  6912. if (!em) {
  6913. set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
  6914. &BTRFS_I(inode)->runtime_flags);
  6915. goto next;
  6916. }
  6917. em->start = cur_offset;
  6918. em->orig_start = cur_offset;
  6919. em->len = ins.offset;
  6920. em->block_start = ins.objectid;
  6921. em->block_len = ins.offset;
  6922. em->orig_block_len = ins.offset;
  6923. em->bdev = root->fs_info->fs_devices->latest_bdev;
  6924. set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
  6925. em->generation = trans->transid;
  6926. while (1) {
  6927. write_lock(&em_tree->lock);
  6928. ret = add_extent_mapping(em_tree, em);
  6929. if (!ret)
  6930. list_move(&em->list,
  6931. &em_tree->modified_extents);
  6932. write_unlock(&em_tree->lock);
  6933. if (ret != -EEXIST)
  6934. break;
  6935. btrfs_drop_extent_cache(inode, cur_offset,
  6936. cur_offset + ins.offset - 1,
  6937. 0);
  6938. }
  6939. free_extent_map(em);
  6940. next:
  6941. num_bytes -= ins.offset;
  6942. cur_offset += ins.offset;
  6943. *alloc_hint = ins.objectid + ins.offset;
  6944. inode_inc_iversion(inode);
  6945. inode->i_ctime = CURRENT_TIME;
  6946. BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
  6947. if (!(mode & FALLOC_FL_KEEP_SIZE) &&
  6948. (actual_len > inode->i_size) &&
  6949. (cur_offset > inode->i_size)) {
  6950. if (cur_offset > actual_len)
  6951. i_size = actual_len;
  6952. else
  6953. i_size = cur_offset;
  6954. i_size_write(inode, i_size);
  6955. btrfs_ordered_update_i_size(inode, i_size, NULL);
  6956. }
  6957. ret = btrfs_update_inode(trans, root, inode);
  6958. if (ret) {
  6959. btrfs_abort_transaction(trans, root, ret);
  6960. if (own_trans)
  6961. btrfs_end_transaction(trans, root);
  6962. break;
  6963. }
  6964. if (own_trans)
  6965. btrfs_end_transaction(trans, root);
  6966. }
  6967. return ret;
  6968. }
  6969. int btrfs_prealloc_file_range(struct inode *inode, int mode,
  6970. u64 start, u64 num_bytes, u64 min_size,
  6971. loff_t actual_len, u64 *alloc_hint)
  6972. {
  6973. return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
  6974. min_size, actual_len, alloc_hint,
  6975. NULL);
  6976. }
  6977. int btrfs_prealloc_file_range_trans(struct inode *inode,
  6978. struct btrfs_trans_handle *trans, int mode,
  6979. u64 start, u64 num_bytes, u64 min_size,
  6980. loff_t actual_len, u64 *alloc_hint)
  6981. {
  6982. return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
  6983. min_size, actual_len, alloc_hint, trans);
  6984. }
  6985. static int btrfs_set_page_dirty(struct page *page)
  6986. {
  6987. return __set_page_dirty_nobuffers(page);
  6988. }
  6989. static int btrfs_permission(struct inode *inode, int mask)
  6990. {
  6991. struct btrfs_root *root = BTRFS_I(inode)->root;
  6992. umode_t mode = inode->i_mode;
  6993. if (mask & MAY_WRITE &&
  6994. (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
  6995. if (btrfs_root_readonly(root))
  6996. return -EROFS;
  6997. if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)
  6998. return -EACCES;
  6999. }
  7000. return generic_permission(inode, mask);
  7001. }
  7002. static const struct inode_operations btrfs_dir_inode_operations = {
  7003. .getattr = btrfs_getattr,
  7004. .lookup = btrfs_lookup,
  7005. .create = btrfs_create,
  7006. .unlink = btrfs_unlink,
  7007. .link = btrfs_link,
  7008. .mkdir = btrfs_mkdir,
  7009. .rmdir = btrfs_rmdir,
  7010. .rename = btrfs_rename,
  7011. .symlink = btrfs_symlink,
  7012. .setattr = btrfs_setattr,
  7013. .mknod = btrfs_mknod,
  7014. .setxattr = btrfs_setxattr,
  7015. .getxattr = btrfs_getxattr,
  7016. .listxattr = btrfs_listxattr,
  7017. .removexattr = btrfs_removexattr,
  7018. .permission = btrfs_permission,
  7019. .get_acl = btrfs_get_acl,
  7020. };
  7021. static const struct inode_operations btrfs_dir_ro_inode_operations = {
  7022. .lookup = btrfs_lookup,
  7023. .permission = btrfs_permission,
  7024. .get_acl = btrfs_get_acl,
  7025. };
  7026. static const struct file_operations btrfs_dir_file_operations = {
  7027. .llseek = generic_file_llseek,
  7028. .read = generic_read_dir,
  7029. .readdir = btrfs_real_readdir,
  7030. .unlocked_ioctl = btrfs_ioctl,
  7031. #ifdef CONFIG_COMPAT
  7032. .compat_ioctl = btrfs_ioctl,
  7033. #endif
  7034. .release = btrfs_release_file,
  7035. .fsync = btrfs_sync_file,
  7036. };
  7037. static struct extent_io_ops btrfs_extent_io_ops = {
  7038. .fill_delalloc = run_delalloc_range,
  7039. .submit_bio_hook = btrfs_submit_bio_hook,
  7040. .merge_bio_hook = btrfs_merge_bio_hook,
  7041. .readpage_end_io_hook = btrfs_readpage_end_io_hook,
  7042. .writepage_end_io_hook = btrfs_writepage_end_io_hook,
  7043. .writepage_start_hook = btrfs_writepage_start_hook,
  7044. .set_bit_hook = btrfs_set_bit_hook,
  7045. .clear_bit_hook = btrfs_clear_bit_hook,
  7046. .merge_extent_hook = btrfs_merge_extent_hook,
  7047. .split_extent_hook = btrfs_split_extent_hook,
  7048. };
  7049. /*
  7050. * btrfs doesn't support the bmap operation because swapfiles
  7051. * use bmap to make a mapping of extents in the file. They assume
  7052. * these extents won't change over the life of the file and they
  7053. * use the bmap result to do IO directly to the drive.
  7054. *
  7055. * the btrfs bmap call would return logical addresses that aren't
  7056. * suitable for IO and they also will change frequently as COW
  7057. * operations happen. So, swapfile + btrfs == corruption.
  7058. *
  7059. * For now we're avoiding this by dropping bmap.
  7060. */
  7061. static const struct address_space_operations btrfs_aops = {
  7062. .readpage = btrfs_readpage,
  7063. .writepage = btrfs_writepage,
  7064. .writepages = btrfs_writepages,
  7065. .readpages = btrfs_readpages,
  7066. .direct_IO = btrfs_direct_IO,
  7067. .invalidatepage = btrfs_invalidatepage,
  7068. .releasepage = btrfs_releasepage,
  7069. .set_page_dirty = btrfs_set_page_dirty,
  7070. .error_remove_page = generic_error_remove_page,
  7071. };
  7072. static const struct address_space_operations btrfs_symlink_aops = {
  7073. .readpage = btrfs_readpage,
  7074. .writepage = btrfs_writepage,
  7075. .invalidatepage = btrfs_invalidatepage,
  7076. .releasepage = btrfs_releasepage,
  7077. };
  7078. static const struct inode_operations btrfs_file_inode_operations = {
  7079. .getattr = btrfs_getattr,
  7080. .setattr = btrfs_setattr,
  7081. .setxattr = btrfs_setxattr,
  7082. .getxattr = btrfs_getxattr,
  7083. .listxattr = btrfs_listxattr,
  7084. .removexattr = btrfs_removexattr,
  7085. .permission = btrfs_permission,
  7086. .fiemap = btrfs_fiemap,
  7087. .get_acl = btrfs_get_acl,
  7088. .update_time = btrfs_update_time,
  7089. };
  7090. static const struct inode_operations btrfs_special_inode_operations = {
  7091. .getattr = btrfs_getattr,
  7092. .setattr = btrfs_setattr,
  7093. .permission = btrfs_permission,
  7094. .setxattr = btrfs_setxattr,
  7095. .getxattr = btrfs_getxattr,
  7096. .listxattr = btrfs_listxattr,
  7097. .removexattr = btrfs_removexattr,
  7098. .get_acl = btrfs_get_acl,
  7099. .update_time = btrfs_update_time,
  7100. };
  7101. static const struct inode_operations btrfs_symlink_inode_operations = {
  7102. .readlink = generic_readlink,
  7103. .follow_link = page_follow_link_light,
  7104. .put_link = page_put_link,
  7105. .getattr = btrfs_getattr,
  7106. .setattr = btrfs_setattr,
  7107. .permission = btrfs_permission,
  7108. .setxattr = btrfs_setxattr,
  7109. .getxattr = btrfs_getxattr,
  7110. .listxattr = btrfs_listxattr,
  7111. .removexattr = btrfs_removexattr,
  7112. .get_acl = btrfs_get_acl,
  7113. .update_time = btrfs_update_time,
  7114. };
  7115. const struct dentry_operations btrfs_dentry_operations = {
  7116. .d_delete = btrfs_dentry_delete,
  7117. .d_release = btrfs_dentry_release,
  7118. };