123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070 |
- // SPDX-License-Identifier: GPL-2.0
- /*
- * Copyright (C) 2007 Oracle. All rights reserved.
- */
- #include <linux/kernel.h>
- #include <linux/bio.h>
- #include <linux/file.h>
- #include <linux/fs.h>
- #include <linux/fsnotify.h>
- #include <linux/pagemap.h>
- #include <linux/highmem.h>
- #include <linux/time.h>
- #include <linux/string.h>
- #include <linux/backing-dev.h>
- #include <linux/mount.h>
- #include <linux/namei.h>
- #include <linux/writeback.h>
- #include <linux/compat.h>
- #include <linux/security.h>
- #include <linux/xattr.h>
- #include <linux/mm.h>
- #include <linux/slab.h>
- #include <linux/blkdev.h>
- #include <linux/uuid.h>
- #include <linux/btrfs.h>
- #include <linux/uaccess.h>
- #include <linux/iversion.h>
- #include "ctree.h"
- #include "disk-io.h"
- #include "export.h"
- #include "transaction.h"
- #include "btrfs_inode.h"
- #include "print-tree.h"
- #include "volumes.h"
- #include "locking.h"
- #include "inode-map.h"
- #include "backref.h"
- #include "rcu-string.h"
- #include "send.h"
- #include "dev-replace.h"
- #include "props.h"
- #include "sysfs.h"
- #include "qgroup.h"
- #include "tree-log.h"
- #include "compression.h"
- #include "space-info.h"
- #include "delalloc-space.h"
- #include "block-group.h"
- #ifdef CONFIG_64BIT
- /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI
- * structures are incorrect, as the timespec structure from userspace
- * is 4 bytes too small. We define these alternatives here to teach
- * the kernel about the 32-bit struct packing.
- */
- struct btrfs_ioctl_timespec_32 {
- __u64 sec;
- __u32 nsec;
- } __attribute__ ((__packed__));
- struct btrfs_ioctl_received_subvol_args_32 {
- char uuid[BTRFS_UUID_SIZE]; /* in */
- __u64 stransid; /* in */
- __u64 rtransid; /* out */
- struct btrfs_ioctl_timespec_32 stime; /* in */
- struct btrfs_ioctl_timespec_32 rtime; /* out */
- __u64 flags; /* in */
- __u64 reserved[16]; /* in */
- } __attribute__ ((__packed__));
- #define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 _IOWR(BTRFS_IOCTL_MAGIC, 37, \
- struct btrfs_ioctl_received_subvol_args_32)
- #endif
- #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
- struct btrfs_ioctl_send_args_32 {
- __s64 send_fd; /* in */
- __u64 clone_sources_count; /* in */
- compat_uptr_t clone_sources; /* in */
- __u64 parent_root; /* in */
- __u64 flags; /* in */
- __u64 reserved[4]; /* in */
- } __attribute__ ((__packed__));
- #define BTRFS_IOC_SEND_32 _IOW(BTRFS_IOCTL_MAGIC, 38, \
- struct btrfs_ioctl_send_args_32)
- #endif
- /* Mask out flags that are inappropriate for the given type of inode. */
- static unsigned int btrfs_mask_fsflags_for_type(struct inode *inode,
- unsigned int flags)
- {
- if (S_ISDIR(inode->i_mode))
- return flags;
- else if (S_ISREG(inode->i_mode))
- return flags & ~FS_DIRSYNC_FL;
- else
- return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
- }
- /*
- * Export internal inode flags to the format expected by the FS_IOC_GETFLAGS
- * ioctl.
- */
- static unsigned int btrfs_inode_flags_to_fsflags(unsigned int flags)
- {
- unsigned int iflags = 0;
- if (flags & BTRFS_INODE_SYNC)
- iflags |= FS_SYNC_FL;
- if (flags & BTRFS_INODE_IMMUTABLE)
- iflags |= FS_IMMUTABLE_FL;
- if (flags & BTRFS_INODE_APPEND)
- iflags |= FS_APPEND_FL;
- if (flags & BTRFS_INODE_NODUMP)
- iflags |= FS_NODUMP_FL;
- if (flags & BTRFS_INODE_NOATIME)
- iflags |= FS_NOATIME_FL;
- if (flags & BTRFS_INODE_DIRSYNC)
- iflags |= FS_DIRSYNC_FL;
- if (flags & BTRFS_INODE_NODATACOW)
- iflags |= FS_NOCOW_FL;
- if (flags & BTRFS_INODE_NOCOMPRESS)
- iflags |= FS_NOCOMP_FL;
- else if (flags & BTRFS_INODE_COMPRESS)
- iflags |= FS_COMPR_FL;
- return iflags;
- }
- /*
- * Update inode->i_flags based on the btrfs internal flags.
- */
- void btrfs_sync_inode_flags_to_i_flags(struct inode *inode)
- {
- struct btrfs_inode *binode = BTRFS_I(inode);
- unsigned int new_fl = 0;
- if (binode->flags & BTRFS_INODE_SYNC)
- new_fl |= S_SYNC;
- if (binode->flags & BTRFS_INODE_IMMUTABLE)
- new_fl |= S_IMMUTABLE;
- if (binode->flags & BTRFS_INODE_APPEND)
- new_fl |= S_APPEND;
- if (binode->flags & BTRFS_INODE_NOATIME)
- new_fl |= S_NOATIME;
- if (binode->flags & BTRFS_INODE_DIRSYNC)
- new_fl |= S_DIRSYNC;
- set_mask_bits(&inode->i_flags,
- S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | S_DIRSYNC,
- new_fl);
- }
- static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
- {
- struct btrfs_inode *binode = BTRFS_I(file_inode(file));
- unsigned int flags = btrfs_inode_flags_to_fsflags(binode->flags);
- if (copy_to_user(arg, &flags, sizeof(flags)))
- return -EFAULT;
- return 0;
- }
- /*
- * Check if @flags are a supported and valid set of FS_*_FL flags and that
- * the old and new flags are not conflicting
- */
- static int check_fsflags(unsigned int old_flags, unsigned int flags)
- {
- if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
- FS_NOATIME_FL | FS_NODUMP_FL | \
- FS_SYNC_FL | FS_DIRSYNC_FL | \
- FS_NOCOMP_FL | FS_COMPR_FL |
- FS_NOCOW_FL))
- return -EOPNOTSUPP;
- /* COMPR and NOCOMP on new/old are valid */
- if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
- return -EINVAL;
- if ((flags & FS_COMPR_FL) && (flags & FS_NOCOW_FL))
- return -EINVAL;
- /* NOCOW and compression options are mutually exclusive */
- if ((old_flags & FS_NOCOW_FL) && (flags & (FS_COMPR_FL | FS_NOCOMP_FL)))
- return -EINVAL;
- if ((flags & FS_NOCOW_FL) && (old_flags & (FS_COMPR_FL | FS_NOCOMP_FL)))
- return -EINVAL;
- return 0;
- }
- static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_inode *binode = BTRFS_I(inode);
- struct btrfs_root *root = binode->root;
- struct btrfs_trans_handle *trans;
- unsigned int fsflags, old_fsflags;
- int ret;
- const char *comp = NULL;
- u32 binode_flags;
- if (!inode_owner_or_capable(inode))
- return -EPERM;
- if (btrfs_root_readonly(root))
- return -EROFS;
- if (copy_from_user(&fsflags, arg, sizeof(fsflags)))
- return -EFAULT;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- inode_lock(inode);
- fsflags = btrfs_mask_fsflags_for_type(inode, fsflags);
- old_fsflags = btrfs_inode_flags_to_fsflags(binode->flags);
- ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);
- if (ret)
- goto out_unlock;
- ret = check_fsflags(old_fsflags, fsflags);
- if (ret)
- goto out_unlock;
- binode_flags = binode->flags;
- if (fsflags & FS_SYNC_FL)
- binode_flags |= BTRFS_INODE_SYNC;
- else
- binode_flags &= ~BTRFS_INODE_SYNC;
- if (fsflags & FS_IMMUTABLE_FL)
- binode_flags |= BTRFS_INODE_IMMUTABLE;
- else
- binode_flags &= ~BTRFS_INODE_IMMUTABLE;
- if (fsflags & FS_APPEND_FL)
- binode_flags |= BTRFS_INODE_APPEND;
- else
- binode_flags &= ~BTRFS_INODE_APPEND;
- if (fsflags & FS_NODUMP_FL)
- binode_flags |= BTRFS_INODE_NODUMP;
- else
- binode_flags &= ~BTRFS_INODE_NODUMP;
- if (fsflags & FS_NOATIME_FL)
- binode_flags |= BTRFS_INODE_NOATIME;
- else
- binode_flags &= ~BTRFS_INODE_NOATIME;
- if (fsflags & FS_DIRSYNC_FL)
- binode_flags |= BTRFS_INODE_DIRSYNC;
- else
- binode_flags &= ~BTRFS_INODE_DIRSYNC;
- if (fsflags & FS_NOCOW_FL) {
- if (S_ISREG(inode->i_mode)) {
- /*
- * It's safe to turn csums off here, no extents exist.
- * Otherwise we want the flag to reflect the real COW
- * status of the file and will not set it.
- */
- if (inode->i_size == 0)
- binode_flags |= BTRFS_INODE_NODATACOW |
- BTRFS_INODE_NODATASUM;
- } else {
- binode_flags |= BTRFS_INODE_NODATACOW;
- }
- } else {
- /*
- * Revert back under same assumptions as above
- */
- if (S_ISREG(inode->i_mode)) {
- if (inode->i_size == 0)
- binode_flags &= ~(BTRFS_INODE_NODATACOW |
- BTRFS_INODE_NODATASUM);
- } else {
- binode_flags &= ~BTRFS_INODE_NODATACOW;
- }
- }
- /*
- * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
- * flag may be changed automatically if compression code won't make
- * things smaller.
- */
- if (fsflags & FS_NOCOMP_FL) {
- binode_flags &= ~BTRFS_INODE_COMPRESS;
- binode_flags |= BTRFS_INODE_NOCOMPRESS;
- } else if (fsflags & FS_COMPR_FL) {
- if (IS_SWAPFILE(inode)) {
- ret = -ETXTBSY;
- goto out_unlock;
- }
- binode_flags |= BTRFS_INODE_COMPRESS;
- binode_flags &= ~BTRFS_INODE_NOCOMPRESS;
- comp = btrfs_compress_type2str(fs_info->compress_type);
- if (!comp || comp[0] == 0)
- comp = btrfs_compress_type2str(BTRFS_COMPRESS_ZLIB);
- } else {
- binode_flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
- }
- /*
- * 1 for inode item
- * 2 for properties
- */
- trans = btrfs_start_transaction(root, 3);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_unlock;
- }
- if (comp) {
- ret = btrfs_set_prop(trans, inode, "btrfs.compression", comp,
- strlen(comp), 0);
- if (ret) {
- btrfs_abort_transaction(trans, ret);
- goto out_end_trans;
- }
- } else {
- ret = btrfs_set_prop(trans, inode, "btrfs.compression", NULL,
- 0, 0);
- if (ret && ret != -ENODATA) {
- btrfs_abort_transaction(trans, ret);
- goto out_end_trans;
- }
- }
- binode->flags = binode_flags;
- btrfs_sync_inode_flags_to_i_flags(inode);
- inode_inc_iversion(inode);
- inode->i_ctime = current_time(inode);
- ret = btrfs_update_inode(trans, root, inode);
- out_end_trans:
- btrfs_end_transaction(trans);
- out_unlock:
- inode_unlock(inode);
- mnt_drop_write_file(file);
- return ret;
- }
- /*
- * Translate btrfs internal inode flags to xflags as expected by the
- * FS_IOC_FSGETXATT ioctl. Filter only the supported ones, unknown flags are
- * silently dropped.
- */
- static unsigned int btrfs_inode_flags_to_xflags(unsigned int flags)
- {
- unsigned int xflags = 0;
- if (flags & BTRFS_INODE_APPEND)
- xflags |= FS_XFLAG_APPEND;
- if (flags & BTRFS_INODE_IMMUTABLE)
- xflags |= FS_XFLAG_IMMUTABLE;
- if (flags & BTRFS_INODE_NOATIME)
- xflags |= FS_XFLAG_NOATIME;
- if (flags & BTRFS_INODE_NODUMP)
- xflags |= FS_XFLAG_NODUMP;
- if (flags & BTRFS_INODE_SYNC)
- xflags |= FS_XFLAG_SYNC;
- return xflags;
- }
- /* Check if @flags are a supported and valid set of FS_XFLAGS_* flags */
- static int check_xflags(unsigned int flags)
- {
- if (flags & ~(FS_XFLAG_APPEND | FS_XFLAG_IMMUTABLE | FS_XFLAG_NOATIME |
- FS_XFLAG_NODUMP | FS_XFLAG_SYNC))
- return -EOPNOTSUPP;
- return 0;
- }
- bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
- enum btrfs_exclusive_operation type)
- {
- return !cmpxchg(&fs_info->exclusive_operation, BTRFS_EXCLOP_NONE, type);
- }
- void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)
- {
- WRITE_ONCE(fs_info->exclusive_operation, BTRFS_EXCLOP_NONE);
- sysfs_notify(&fs_info->fs_devices->fsid_kobj, NULL, "exclusive_operation");
- }
- /*
- * Set the xflags from the internal inode flags. The remaining items of fsxattr
- * are zeroed.
- */
- static int btrfs_ioctl_fsgetxattr(struct file *file, void __user *arg)
- {
- struct btrfs_inode *binode = BTRFS_I(file_inode(file));
- struct fsxattr fa;
- simple_fill_fsxattr(&fa, btrfs_inode_flags_to_xflags(binode->flags));
- if (copy_to_user(arg, &fa, sizeof(fa)))
- return -EFAULT;
- return 0;
- }
- static int btrfs_ioctl_fssetxattr(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_inode *binode = BTRFS_I(inode);
- struct btrfs_root *root = binode->root;
- struct btrfs_trans_handle *trans;
- struct fsxattr fa, old_fa;
- unsigned old_flags;
- unsigned old_i_flags;
- int ret = 0;
- if (!inode_owner_or_capable(inode))
- return -EPERM;
- if (btrfs_root_readonly(root))
- return -EROFS;
- if (copy_from_user(&fa, arg, sizeof(fa)))
- return -EFAULT;
- ret = check_xflags(fa.fsx_xflags);
- if (ret)
- return ret;
- if (fa.fsx_extsize != 0 || fa.fsx_projid != 0 || fa.fsx_cowextsize != 0)
- return -EOPNOTSUPP;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- inode_lock(inode);
- old_flags = binode->flags;
- old_i_flags = inode->i_flags;
- simple_fill_fsxattr(&old_fa,
- btrfs_inode_flags_to_xflags(binode->flags));
- ret = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);
- if (ret)
- goto out_unlock;
- if (fa.fsx_xflags & FS_XFLAG_SYNC)
- binode->flags |= BTRFS_INODE_SYNC;
- else
- binode->flags &= ~BTRFS_INODE_SYNC;
- if (fa.fsx_xflags & FS_XFLAG_IMMUTABLE)
- binode->flags |= BTRFS_INODE_IMMUTABLE;
- else
- binode->flags &= ~BTRFS_INODE_IMMUTABLE;
- if (fa.fsx_xflags & FS_XFLAG_APPEND)
- binode->flags |= BTRFS_INODE_APPEND;
- else
- binode->flags &= ~BTRFS_INODE_APPEND;
- if (fa.fsx_xflags & FS_XFLAG_NODUMP)
- binode->flags |= BTRFS_INODE_NODUMP;
- else
- binode->flags &= ~BTRFS_INODE_NODUMP;
- if (fa.fsx_xflags & FS_XFLAG_NOATIME)
- binode->flags |= BTRFS_INODE_NOATIME;
- else
- binode->flags &= ~BTRFS_INODE_NOATIME;
- /* 1 item for the inode */
- trans = btrfs_start_transaction(root, 1);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_unlock;
- }
- btrfs_sync_inode_flags_to_i_flags(inode);
- inode_inc_iversion(inode);
- inode->i_ctime = current_time(inode);
- ret = btrfs_update_inode(trans, root, inode);
- btrfs_end_transaction(trans);
- out_unlock:
- if (ret) {
- binode->flags = old_flags;
- inode->i_flags = old_i_flags;
- }
- inode_unlock(inode);
- mnt_drop_write_file(file);
- return ret;
- }
- static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
- {
- struct inode *inode = file_inode(file);
- return put_user(inode->i_generation, arg);
- }
- static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_device *device;
- struct request_queue *q;
- struct fstrim_range range;
- u64 minlen = ULLONG_MAX;
- u64 num_devices = 0;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- /*
- * If the fs is mounted with nologreplay, which requires it to be
- * mounted in RO mode as well, we can not allow discard on free space
- * inside block groups, because log trees refer to extents that are not
- * pinned in a block group's free space cache (pinning the extents is
- * precisely the first phase of replaying a log tree).
- */
- if (btrfs_test_opt(fs_info, NOLOGREPLAY))
- return -EROFS;
- rcu_read_lock();
- list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
- dev_list) {
- if (!device->bdev)
- continue;
- q = bdev_get_queue(device->bdev);
- if (blk_queue_discard(q)) {
- num_devices++;
- minlen = min_t(u64, q->limits.discard_granularity,
- minlen);
- }
- }
- rcu_read_unlock();
- if (!num_devices)
- return -EOPNOTSUPP;
- if (copy_from_user(&range, arg, sizeof(range)))
- return -EFAULT;
- /*
- * NOTE: Don't truncate the range using super->total_bytes. Bytenr of
- * block group is in the logical address space, which can be any
- * sectorsize aligned bytenr in the range [0, U64_MAX].
- */
- if (range.len < fs_info->sb->s_blocksize)
- return -EINVAL;
- range.minlen = max(range.minlen, minlen);
- ret = btrfs_trim_fs(fs_info, &range);
- if (ret < 0)
- return ret;
- if (copy_to_user(arg, &range, sizeof(range)))
- return -EFAULT;
- return 0;
- }
- int __pure btrfs_is_empty_uuid(u8 *uuid)
- {
- int i;
- for (i = 0; i < BTRFS_UUID_SIZE; i++) {
- if (uuid[i])
- return 0;
- }
- return 1;
- }
- static noinline int create_subvol(struct inode *dir,
- struct dentry *dentry,
- const char *name, int namelen,
- struct btrfs_qgroup_inherit *inherit)
- {
- struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
- struct btrfs_trans_handle *trans;
- struct btrfs_key key;
- struct btrfs_root_item *root_item;
- struct btrfs_inode_item *inode_item;
- struct extent_buffer *leaf;
- struct btrfs_root *root = BTRFS_I(dir)->root;
- struct btrfs_root *new_root;
- struct btrfs_block_rsv block_rsv;
- struct timespec64 cur_time = current_time(dir);
- struct inode *inode;
- int ret;
- int err;
- dev_t anon_dev = 0;
- u64 objectid;
- u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
- u64 index = 0;
- root_item = kzalloc(sizeof(*root_item), GFP_KERNEL);
- if (!root_item)
- return -ENOMEM;
- ret = btrfs_find_free_objectid(fs_info->tree_root, &objectid);
- if (ret)
- goto fail_free;
- ret = get_anon_bdev(&anon_dev);
- if (ret < 0)
- goto fail_free;
- /*
- * Don't create subvolume whose level is not zero. Or qgroup will be
- * screwed up since it assumes subvolume qgroup's level to be 0.
- */
- if (btrfs_qgroup_level(objectid)) {
- ret = -ENOSPC;
- goto fail_free;
- }
- btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
- /*
- * The same as the snapshot creation, please see the comment
- * of create_snapshot().
- */
- ret = btrfs_subvolume_reserve_metadata(root, &block_rsv, 8, false);
- if (ret)
- goto fail_free;
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- btrfs_subvolume_release_metadata(root, &block_rsv);
- goto fail_free;
- }
- trans->block_rsv = &block_rsv;
- trans->bytes_reserved = block_rsv.size;
- ret = btrfs_qgroup_inherit(trans, 0, objectid, inherit);
- if (ret)
- goto fail;
- leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,
- BTRFS_NESTING_NORMAL);
- if (IS_ERR(leaf)) {
- ret = PTR_ERR(leaf);
- goto fail;
- }
- btrfs_mark_buffer_dirty(leaf);
- inode_item = &root_item->inode;
- btrfs_set_stack_inode_generation(inode_item, 1);
- btrfs_set_stack_inode_size(inode_item, 3);
- btrfs_set_stack_inode_nlink(inode_item, 1);
- btrfs_set_stack_inode_nbytes(inode_item,
- fs_info->nodesize);
- btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
- btrfs_set_root_flags(root_item, 0);
- btrfs_set_root_limit(root_item, 0);
- btrfs_set_stack_inode_flags(inode_item, BTRFS_INODE_ROOT_ITEM_INIT);
- btrfs_set_root_bytenr(root_item, leaf->start);
- btrfs_set_root_generation(root_item, trans->transid);
- btrfs_set_root_level(root_item, 0);
- btrfs_set_root_refs(root_item, 1);
- btrfs_set_root_used(root_item, leaf->len);
- btrfs_set_root_last_snapshot(root_item, 0);
- btrfs_set_root_generation_v2(root_item,
- btrfs_root_generation(root_item));
- generate_random_guid(root_item->uuid);
- btrfs_set_stack_timespec_sec(&root_item->otime, cur_time.tv_sec);
- btrfs_set_stack_timespec_nsec(&root_item->otime, cur_time.tv_nsec);
- root_item->ctime = root_item->otime;
- btrfs_set_root_ctransid(root_item, trans->transid);
- btrfs_set_root_otransid(root_item, trans->transid);
- btrfs_tree_unlock(leaf);
- btrfs_set_root_dirid(root_item, new_dirid);
- key.objectid = objectid;
- key.offset = 0;
- key.type = BTRFS_ROOT_ITEM_KEY;
- ret = btrfs_insert_root(trans, fs_info->tree_root, &key,
- root_item);
- if (ret) {
- /*
- * Since we don't abort the transaction in this case, free the
- * tree block so that we don't leak space and leave the
- * filesystem in an inconsistent state (an extent item in the
- * extent tree without backreferences). Also no need to have
- * the tree block locked since it is not in any tree at this
- * point, so no other task can find it and use it.
- */
- btrfs_free_tree_block(trans, root, leaf, 0, 1);
- free_extent_buffer(leaf);
- goto fail;
- }
- free_extent_buffer(leaf);
- leaf = NULL;
- key.offset = (u64)-1;
- new_root = btrfs_get_new_fs_root(fs_info, objectid, anon_dev);
- if (IS_ERR(new_root)) {
- free_anon_bdev(anon_dev);
- ret = PTR_ERR(new_root);
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- /* Freeing will be done in btrfs_put_root() of new_root */
- anon_dev = 0;
- btrfs_record_root_in_trans(trans, new_root);
- ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
- btrfs_put_root(new_root);
- if (ret) {
- /* We potentially lose an unused inode item here */
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- mutex_lock(&new_root->objectid_mutex);
- new_root->highest_objectid = new_dirid;
- mutex_unlock(&new_root->objectid_mutex);
- /*
- * insert the directory item
- */
- ret = btrfs_set_inode_index(BTRFS_I(dir), &index);
- if (ret) {
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- ret = btrfs_insert_dir_item(trans, name, namelen, BTRFS_I(dir), &key,
- BTRFS_FT_DIR, index);
- if (ret) {
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- btrfs_i_size_write(BTRFS_I(dir), dir->i_size + namelen * 2);
- ret = btrfs_update_inode(trans, root, dir);
- if (ret) {
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- ret = btrfs_add_root_ref(trans, objectid, root->root_key.objectid,
- btrfs_ino(BTRFS_I(dir)), index, name, namelen);
- if (ret) {
- btrfs_abort_transaction(trans, ret);
- goto fail;
- }
- ret = btrfs_uuid_tree_add(trans, root_item->uuid,
- BTRFS_UUID_KEY_SUBVOL, objectid);
- if (ret)
- btrfs_abort_transaction(trans, ret);
- fail:
- kfree(root_item);
- trans->block_rsv = NULL;
- trans->bytes_reserved = 0;
- btrfs_subvolume_release_metadata(root, &block_rsv);
- err = btrfs_commit_transaction(trans);
- if (err && !ret)
- ret = err;
- if (!ret) {
- inode = btrfs_lookup_dentry(dir, dentry);
- if (IS_ERR(inode))
- return PTR_ERR(inode);
- d_instantiate(dentry, inode);
- }
- return ret;
- fail_free:
- if (anon_dev)
- free_anon_bdev(anon_dev);
- kfree(root_item);
- return ret;
- }
- static int create_snapshot(struct btrfs_root *root, struct inode *dir,
- struct dentry *dentry, bool readonly,
- struct btrfs_qgroup_inherit *inherit)
- {
- struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
- struct inode *inode;
- struct btrfs_pending_snapshot *pending_snapshot;
- struct btrfs_trans_handle *trans;
- int ret;
- if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
- return -EINVAL;
- if (atomic_read(&root->nr_swapfiles)) {
- btrfs_warn(fs_info,
- "cannot snapshot subvolume with active swapfile");
- return -ETXTBSY;
- }
- pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_KERNEL);
- if (!pending_snapshot)
- return -ENOMEM;
- ret = get_anon_bdev(&pending_snapshot->anon_dev);
- if (ret < 0)
- goto free_pending;
- pending_snapshot->root_item = kzalloc(sizeof(struct btrfs_root_item),
- GFP_KERNEL);
- pending_snapshot->path = btrfs_alloc_path();
- if (!pending_snapshot->root_item || !pending_snapshot->path) {
- ret = -ENOMEM;
- goto free_pending;
- }
- btrfs_init_block_rsv(&pending_snapshot->block_rsv,
- BTRFS_BLOCK_RSV_TEMP);
- /*
- * 1 - parent dir inode
- * 2 - dir entries
- * 1 - root item
- * 2 - root ref/backref
- * 1 - root of snapshot
- * 1 - UUID item
- */
- ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
- &pending_snapshot->block_rsv, 8,
- false);
- if (ret)
- goto free_pending;
- pending_snapshot->dentry = dentry;
- pending_snapshot->root = root;
- pending_snapshot->readonly = readonly;
- pending_snapshot->dir = dir;
- pending_snapshot->inherit = inherit;
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto fail;
- }
- spin_lock(&fs_info->trans_lock);
- list_add(&pending_snapshot->list,
- &trans->transaction->pending_snapshots);
- spin_unlock(&fs_info->trans_lock);
- ret = btrfs_commit_transaction(trans);
- if (ret)
- goto fail;
- ret = pending_snapshot->error;
- if (ret)
- goto fail;
- ret = btrfs_orphan_cleanup(pending_snapshot->snap);
- if (ret)
- goto fail;
- inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);
- if (IS_ERR(inode)) {
- ret = PTR_ERR(inode);
- goto fail;
- }
- d_instantiate(dentry, inode);
- ret = 0;
- pending_snapshot->anon_dev = 0;
- fail:
- /* Prevent double freeing of anon_dev */
- if (ret && pending_snapshot->snap)
- pending_snapshot->snap->anon_dev = 0;
- btrfs_put_root(pending_snapshot->snap);
- btrfs_subvolume_release_metadata(root, &pending_snapshot->block_rsv);
- free_pending:
- if (pending_snapshot->anon_dev)
- free_anon_bdev(pending_snapshot->anon_dev);
- kfree(pending_snapshot->root_item);
- btrfs_free_path(pending_snapshot->path);
- kfree(pending_snapshot);
- return ret;
- }
- /* copy of may_delete in fs/namei.c()
- * Check whether we can remove a link victim from directory dir, check
- * whether the type of victim is right.
- * 1. We can't do it if dir is read-only (done in permission())
- * 2. We should have write and exec permissions on dir
- * 3. We can't remove anything from append-only dir
- * 4. We can't do anything with immutable dir (done in permission())
- * 5. If the sticky bit on dir is set we should either
- * a. be owner of dir, or
- * b. be owner of victim, or
- * c. have CAP_FOWNER capability
- * 6. If the victim is append-only or immutable we can't do anything with
- * links pointing to it.
- * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
- * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
- * 9. We can't remove a root or mountpoint.
- * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
- * nfs_async_unlink().
- */
- static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
- {
- int error;
- if (d_really_is_negative(victim))
- return -ENOENT;
- BUG_ON(d_inode(victim->d_parent) != dir);
- audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
- error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
- if (error)
- return error;
- if (IS_APPEND(dir))
- return -EPERM;
- if (check_sticky(dir, d_inode(victim)) || IS_APPEND(d_inode(victim)) ||
- IS_IMMUTABLE(d_inode(victim)) || IS_SWAPFILE(d_inode(victim)))
- return -EPERM;
- if (isdir) {
- if (!d_is_dir(victim))
- return -ENOTDIR;
- if (IS_ROOT(victim))
- return -EBUSY;
- } else if (d_is_dir(victim))
- return -EISDIR;
- if (IS_DEADDIR(dir))
- return -ENOENT;
- if (victim->d_flags & DCACHE_NFSFS_RENAMED)
- return -EBUSY;
- return 0;
- }
- /* copy of may_create in fs/namei.c() */
- static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
- {
- if (d_really_is_positive(child))
- return -EEXIST;
- if (IS_DEADDIR(dir))
- return -ENOENT;
- return inode_permission(dir, MAY_WRITE | MAY_EXEC);
- }
- /*
- * Create a new subvolume below @parent. This is largely modeled after
- * sys_mkdirat and vfs_mkdir, but we only do a single component lookup
- * inside this filesystem so it's quite a bit simpler.
- */
- static noinline int btrfs_mksubvol(const struct path *parent,
- const char *name, int namelen,
- struct btrfs_root *snap_src,
- bool readonly,
- struct btrfs_qgroup_inherit *inherit)
- {
- struct inode *dir = d_inode(parent->dentry);
- struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
- struct dentry *dentry;
- int error;
- error = down_write_killable_nested(&dir->i_rwsem, I_MUTEX_PARENT);
- if (error == -EINTR)
- return error;
- dentry = lookup_one_len(name, parent->dentry, namelen);
- error = PTR_ERR(dentry);
- if (IS_ERR(dentry))
- goto out_unlock;
- error = btrfs_may_create(dir, dentry);
- if (error)
- goto out_dput;
- /*
- * even if this name doesn't exist, we may get hash collisions.
- * check for them now when we can safely fail
- */
- error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
- dir->i_ino, name,
- namelen);
- if (error)
- goto out_dput;
- down_read(&fs_info->subvol_sem);
- if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
- goto out_up_read;
- if (snap_src)
- error = create_snapshot(snap_src, dir, dentry, readonly, inherit);
- else
- error = create_subvol(dir, dentry, name, namelen, inherit);
- if (!error)
- fsnotify_mkdir(dir, dentry);
- out_up_read:
- up_read(&fs_info->subvol_sem);
- out_dput:
- dput(dentry);
- out_unlock:
- inode_unlock(dir);
- return error;
- }
- static noinline int btrfs_mksnapshot(const struct path *parent,
- const char *name, int namelen,
- struct btrfs_root *root,
- bool readonly,
- struct btrfs_qgroup_inherit *inherit)
- {
- int ret;
- bool snapshot_force_cow = false;
- /*
- * Force new buffered writes to reserve space even when NOCOW is
- * possible. This is to avoid later writeback (running dealloc) to
- * fallback to COW mode and unexpectedly fail with ENOSPC.
- */
- btrfs_drew_read_lock(&root->snapshot_lock);
- ret = btrfs_start_delalloc_snapshot(root);
- if (ret)
- goto out;
- /*
- * All previous writes have started writeback in NOCOW mode, so now
- * we force future writes to fallback to COW mode during snapshot
- * creation.
- */
- atomic_inc(&root->snapshot_force_cow);
- snapshot_force_cow = true;
- btrfs_wait_ordered_extents(root, U64_MAX, 0, (u64)-1);
- ret = btrfs_mksubvol(parent, name, namelen,
- root, readonly, inherit);
- out:
- if (snapshot_force_cow)
- atomic_dec(&root->snapshot_force_cow);
- btrfs_drew_read_unlock(&root->snapshot_lock);
- return ret;
- }
- /*
- * When we're defragging a range, we don't want to kick it off again
- * if it is really just waiting for delalloc to send it down.
- * If we find a nice big extent or delalloc range for the bytes in the
- * file you want to defrag, we return 0 to let you know to skip this
- * part of the file
- */
- static int check_defrag_in_cache(struct inode *inode, u64 offset, u32 thresh)
- {
- struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
- struct extent_map *em = NULL;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
- u64 end;
- read_lock(&em_tree->lock);
- em = lookup_extent_mapping(em_tree, offset, PAGE_SIZE);
- read_unlock(&em_tree->lock);
- if (em) {
- end = extent_map_end(em);
- free_extent_map(em);
- if (end - offset > thresh)
- return 0;
- }
- /* if we already have a nice delalloc here, just stop */
- thresh /= 2;
- end = count_range_bits(io_tree, &offset, offset + thresh,
- thresh, EXTENT_DELALLOC, 1);
- if (end >= thresh)
- return 0;
- return 1;
- }
- /*
- * helper function to walk through a file and find extents
- * newer than a specific transid, and smaller than thresh.
- *
- * This is used by the defragging code to find new and small
- * extents
- */
- static int find_new_extents(struct btrfs_root *root,
- struct inode *inode, u64 newer_than,
- u64 *off, u32 thresh)
- {
- struct btrfs_path *path;
- struct btrfs_key min_key;
- struct extent_buffer *leaf;
- struct btrfs_file_extent_item *extent;
- int type;
- int ret;
- u64 ino = btrfs_ino(BTRFS_I(inode));
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- min_key.objectid = ino;
- min_key.type = BTRFS_EXTENT_DATA_KEY;
- min_key.offset = *off;
- while (1) {
- ret = btrfs_search_forward(root, &min_key, path, newer_than);
- if (ret != 0)
- goto none;
- process_slot:
- if (min_key.objectid != ino)
- goto none;
- if (min_key.type != BTRFS_EXTENT_DATA_KEY)
- goto none;
- leaf = path->nodes[0];
- extent = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_file_extent_item);
- type = btrfs_file_extent_type(leaf, extent);
- if (type == BTRFS_FILE_EXTENT_REG &&
- btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
- check_defrag_in_cache(inode, min_key.offset, thresh)) {
- *off = min_key.offset;
- btrfs_free_path(path);
- return 0;
- }
- path->slots[0]++;
- if (path->slots[0] < btrfs_header_nritems(leaf)) {
- btrfs_item_key_to_cpu(leaf, &min_key, path->slots[0]);
- goto process_slot;
- }
- if (min_key.offset == (u64)-1)
- goto none;
- min_key.offset++;
- btrfs_release_path(path);
- }
- none:
- btrfs_free_path(path);
- return -ENOENT;
- }
- static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
- {
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
- struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
- struct extent_map *em;
- u64 len = PAGE_SIZE;
- /*
- * hopefully we have this extent in the tree already, try without
- * the full extent lock
- */
- read_lock(&em_tree->lock);
- em = lookup_extent_mapping(em_tree, start, len);
- read_unlock(&em_tree->lock);
- if (!em) {
- struct extent_state *cached = NULL;
- u64 end = start + len - 1;
- /* get the big lock and read metadata off disk */
- lock_extent_bits(io_tree, start, end, &cached);
- em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len);
- unlock_extent_cached(io_tree, start, end, &cached);
- if (IS_ERR(em))
- return NULL;
- }
- return em;
- }
- static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
- {
- struct extent_map *next;
- bool ret = true;
- /* this is the last extent */
- if (em->start + em->len >= i_size_read(inode))
- return false;
- next = defrag_lookup_extent(inode, em->start + em->len);
- if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE)
- ret = false;
- else if ((em->block_start + em->block_len == next->block_start) &&
- (em->block_len > SZ_128K && next->block_len > SZ_128K))
- ret = false;
- free_extent_map(next);
- return ret;
- }
- static int should_defrag_range(struct inode *inode, u64 start, u32 thresh,
- u64 *last_len, u64 *skip, u64 *defrag_end,
- int compress)
- {
- struct extent_map *em;
- int ret = 1;
- bool next_mergeable = true;
- bool prev_mergeable = true;
- /*
- * make sure that once we start defragging an extent, we keep on
- * defragging it
- */
- if (start < *defrag_end)
- return 1;
- *skip = 0;
- em = defrag_lookup_extent(inode, start);
- if (!em)
- return 0;
- /* this will cover holes, and inline extents */
- if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
- ret = 0;
- goto out;
- }
- if (!*defrag_end)
- prev_mergeable = false;
- next_mergeable = defrag_check_next_extent(inode, em);
- /*
- * we hit a real extent, if it is big or the next extent is not a
- * real extent, don't bother defragging it
- */
- if (!compress && (*last_len == 0 || *last_len >= thresh) &&
- (em->len >= thresh || (!next_mergeable && !prev_mergeable)))
- ret = 0;
- out:
- /*
- * last_len ends up being a counter of how many bytes we've defragged.
- * every time we choose not to defrag an extent, we reset *last_len
- * so that the next tiny extent will force a defrag.
- *
- * The end result of this is that tiny extents before a single big
- * extent will force at least part of that big extent to be defragged.
- */
- if (ret) {
- *defrag_end = extent_map_end(em);
- } else {
- *last_len = 0;
- *skip = extent_map_end(em);
- *defrag_end = 0;
- }
- free_extent_map(em);
- return ret;
- }
- /*
- * it doesn't do much good to defrag one or two pages
- * at a time. This pulls in a nice chunk of pages
- * to COW and defrag.
- *
- * It also makes sure the delalloc code has enough
- * dirty data to avoid making new small extents as part
- * of the defrag
- *
- * It's a good idea to start RA on this range
- * before calling this.
- */
- static int cluster_pages_for_defrag(struct inode *inode,
- struct page **pages,
- unsigned long start_index,
- unsigned long num_pages)
- {
- unsigned long file_end;
- u64 isize = i_size_read(inode);
- u64 page_start;
- u64 page_end;
- u64 page_cnt;
- u64 start = (u64)start_index << PAGE_SHIFT;
- u64 search_start;
- int ret;
- int i;
- int i_done;
- struct btrfs_ordered_extent *ordered;
- struct extent_state *cached_state = NULL;
- struct extent_io_tree *tree;
- struct extent_changeset *data_reserved = NULL;
- gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
- file_end = (isize - 1) >> PAGE_SHIFT;
- if (!isize || start_index > file_end)
- return 0;
- page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1);
- ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
- start, page_cnt << PAGE_SHIFT);
- if (ret)
- return ret;
- i_done = 0;
- tree = &BTRFS_I(inode)->io_tree;
- /* step one, lock all the pages */
- for (i = 0; i < page_cnt; i++) {
- struct page *page;
- again:
- page = find_or_create_page(inode->i_mapping,
- start_index + i, mask);
- if (!page)
- break;
- page_start = page_offset(page);
- page_end = page_start + PAGE_SIZE - 1;
- while (1) {
- lock_extent_bits(tree, page_start, page_end,
- &cached_state);
- ordered = btrfs_lookup_ordered_extent(BTRFS_I(inode),
- page_start);
- unlock_extent_cached(tree, page_start, page_end,
- &cached_state);
- if (!ordered)
- break;
- unlock_page(page);
- btrfs_start_ordered_extent(ordered, 1);
- btrfs_put_ordered_extent(ordered);
- lock_page(page);
- /*
- * we unlocked the page above, so we need check if
- * it was released or not.
- */
- if (page->mapping != inode->i_mapping) {
- unlock_page(page);
- put_page(page);
- goto again;
- }
- }
- if (!PageUptodate(page)) {
- btrfs_readpage(NULL, page);
- lock_page(page);
- if (!PageUptodate(page)) {
- unlock_page(page);
- put_page(page);
- ret = -EIO;
- break;
- }
- }
- if (page->mapping != inode->i_mapping) {
- unlock_page(page);
- put_page(page);
- goto again;
- }
- pages[i] = page;
- i_done++;
- }
- if (!i_done || ret)
- goto out;
- if (!(inode->i_sb->s_flags & SB_ACTIVE))
- goto out;
- /*
- * so now we have a nice long stream of locked
- * and up to date pages, lets wait on them
- */
- for (i = 0; i < i_done; i++)
- wait_on_page_writeback(pages[i]);
- page_start = page_offset(pages[0]);
- page_end = page_offset(pages[i_done - 1]) + PAGE_SIZE;
- lock_extent_bits(&BTRFS_I(inode)->io_tree,
- page_start, page_end - 1, &cached_state);
- /*
- * When defragmenting we skip ranges that have holes or inline extents,
- * (check should_defrag_range()), to avoid unnecessary IO and wasting
- * space. At btrfs_defrag_file(), we check if a range should be defragged
- * before locking the inode and then, if it should, we trigger a sync
- * page cache readahead - we lock the inode only after that to avoid
- * blocking for too long other tasks that possibly want to operate on
- * other file ranges. But before we were able to get the inode lock,
- * some other task may have punched a hole in the range, or we may have
- * now an inline extent, in which case we should not defrag. So check
- * for that here, where we have the inode and the range locked, and bail
- * out if that happened.
- */
- search_start = page_start;
- while (search_start < page_end) {
- struct extent_map *em;
- em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, search_start,
- page_end - search_start);
- if (IS_ERR(em)) {
- ret = PTR_ERR(em);
- goto out_unlock_range;
- }
- if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
- free_extent_map(em);
- /* Ok, 0 means we did not defrag anything */
- ret = 0;
- goto out_unlock_range;
- }
- search_start = extent_map_end(em);
- free_extent_map(em);
- }
- clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
- page_end - 1, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
- EXTENT_DEFRAG, 0, 0, &cached_state);
- if (i_done != page_cnt) {
- spin_lock(&BTRFS_I(inode)->lock);
- btrfs_mod_outstanding_extents(BTRFS_I(inode), 1);
- spin_unlock(&BTRFS_I(inode)->lock);
- btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
- start, (page_cnt - i_done) << PAGE_SHIFT, true);
- }
- set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
- &cached_state);
- unlock_extent_cached(&BTRFS_I(inode)->io_tree,
- page_start, page_end - 1, &cached_state);
- for (i = 0; i < i_done; i++) {
- clear_page_dirty_for_io(pages[i]);
- ClearPageChecked(pages[i]);
- set_page_extent_mapped(pages[i]);
- set_page_dirty(pages[i]);
- unlock_page(pages[i]);
- put_page(pages[i]);
- }
- btrfs_delalloc_release_extents(BTRFS_I(inode), page_cnt << PAGE_SHIFT);
- extent_changeset_free(data_reserved);
- return i_done;
- out_unlock_range:
- unlock_extent_cached(&BTRFS_I(inode)->io_tree,
- page_start, page_end - 1, &cached_state);
- out:
- for (i = 0; i < i_done; i++) {
- unlock_page(pages[i]);
- put_page(pages[i]);
- }
- btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved,
- start, page_cnt << PAGE_SHIFT, true);
- btrfs_delalloc_release_extents(BTRFS_I(inode), page_cnt << PAGE_SHIFT);
- extent_changeset_free(data_reserved);
- return ret;
- }
- int btrfs_defrag_file(struct inode *inode, struct file *file,
- struct btrfs_ioctl_defrag_range_args *range,
- u64 newer_than, unsigned long max_to_defrag)
- {
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct file_ra_state *ra = NULL;
- unsigned long last_index;
- u64 isize = i_size_read(inode);
- u64 last_len = 0;
- u64 skip = 0;
- u64 defrag_end = 0;
- u64 newer_off = range->start;
- unsigned long i;
- unsigned long ra_index = 0;
- int ret;
- int defrag_count = 0;
- int compress_type = BTRFS_COMPRESS_ZLIB;
- u32 extent_thresh = range->extent_thresh;
- unsigned long max_cluster = SZ_256K >> PAGE_SHIFT;
- unsigned long cluster = max_cluster;
- u64 new_align = ~((u64)SZ_128K - 1);
- struct page **pages = NULL;
- bool do_compress = range->flags & BTRFS_DEFRAG_RANGE_COMPRESS;
- if (isize == 0)
- return 0;
- if (range->start >= isize)
- return -EINVAL;
- if (do_compress) {
- if (range->compress_type >= BTRFS_NR_COMPRESS_TYPES)
- return -EINVAL;
- if (range->compress_type)
- compress_type = range->compress_type;
- }
- if (extent_thresh == 0)
- extent_thresh = SZ_256K;
- /*
- * If we were not given a file, allocate a readahead context. As
- * readahead is just an optimization, defrag will work without it so
- * we don't error out.
- */
- if (!file) {
- ra = kzalloc(sizeof(*ra), GFP_KERNEL);
- if (ra)
- file_ra_state_init(ra, inode->i_mapping);
- } else {
- ra = &file->f_ra;
- }
- pages = kmalloc_array(max_cluster, sizeof(struct page *), GFP_KERNEL);
- if (!pages) {
- ret = -ENOMEM;
- goto out_ra;
- }
- /* find the last page to defrag */
- if (range->start + range->len > range->start) {
- last_index = min_t(u64, isize - 1,
- range->start + range->len - 1) >> PAGE_SHIFT;
- } else {
- last_index = (isize - 1) >> PAGE_SHIFT;
- }
- if (newer_than) {
- ret = find_new_extents(root, inode, newer_than,
- &newer_off, SZ_64K);
- if (!ret) {
- range->start = newer_off;
- /*
- * we always align our defrag to help keep
- * the extents in the file evenly spaced
- */
- i = (newer_off & new_align) >> PAGE_SHIFT;
- } else
- goto out_ra;
- } else {
- i = range->start >> PAGE_SHIFT;
- }
- if (!max_to_defrag)
- max_to_defrag = last_index - i + 1;
- /*
- * make writeback starts from i, so the defrag range can be
- * written sequentially.
- */
- if (i < inode->i_mapping->writeback_index)
- inode->i_mapping->writeback_index = i;
- while (i <= last_index && defrag_count < max_to_defrag &&
- (i < DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE))) {
- /*
- * make sure we stop running if someone unmounts
- * the FS
- */
- if (!(inode->i_sb->s_flags & SB_ACTIVE))
- break;
- if (btrfs_defrag_cancelled(fs_info)) {
- btrfs_debug(fs_info, "defrag_file cancelled");
- ret = -EAGAIN;
- break;
- }
- if (!should_defrag_range(inode, (u64)i << PAGE_SHIFT,
- extent_thresh, &last_len, &skip,
- &defrag_end, do_compress)){
- unsigned long next;
- /*
- * the should_defrag function tells us how much to skip
- * bump our counter by the suggested amount
- */
- next = DIV_ROUND_UP(skip, PAGE_SIZE);
- i = max(i + 1, next);
- continue;
- }
- if (!newer_than) {
- cluster = (PAGE_ALIGN(defrag_end) >>
- PAGE_SHIFT) - i;
- cluster = min(cluster, max_cluster);
- } else {
- cluster = max_cluster;
- }
- if (i + cluster > ra_index) {
- ra_index = max(i, ra_index);
- if (ra)
- page_cache_sync_readahead(inode->i_mapping, ra,
- file, ra_index, cluster);
- ra_index += cluster;
- }
- inode_lock(inode);
- if (IS_SWAPFILE(inode)) {
- ret = -ETXTBSY;
- } else {
- if (do_compress)
- BTRFS_I(inode)->defrag_compress = compress_type;
- ret = cluster_pages_for_defrag(inode, pages, i, cluster);
- }
- if (ret < 0) {
- inode_unlock(inode);
- goto out_ra;
- }
- defrag_count += ret;
- balance_dirty_pages_ratelimited(inode->i_mapping);
- inode_unlock(inode);
- if (newer_than) {
- if (newer_off == (u64)-1)
- break;
- if (ret > 0)
- i += ret;
- newer_off = max(newer_off + 1,
- (u64)i << PAGE_SHIFT);
- ret = find_new_extents(root, inode, newer_than,
- &newer_off, SZ_64K);
- if (!ret) {
- range->start = newer_off;
- i = (newer_off & new_align) >> PAGE_SHIFT;
- } else {
- break;
- }
- } else {
- if (ret > 0) {
- i += ret;
- last_len += ret << PAGE_SHIFT;
- } else {
- i++;
- last_len = 0;
- }
- }
- }
- if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO)) {
- filemap_flush(inode->i_mapping);
- if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
- &BTRFS_I(inode)->runtime_flags))
- filemap_flush(inode->i_mapping);
- }
- if (range->compress_type == BTRFS_COMPRESS_LZO) {
- btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);
- } else if (range->compress_type == BTRFS_COMPRESS_ZSTD) {
- btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);
- }
- ret = defrag_count;
- out_ra:
- if (do_compress) {
- inode_lock(inode);
- BTRFS_I(inode)->defrag_compress = BTRFS_COMPRESS_NONE;
- inode_unlock(inode);
- }
- if (!file)
- kfree(ra);
- kfree(pages);
- return ret;
- }
- static noinline int btrfs_ioctl_resize(struct file *file,
- void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- u64 new_size;
- u64 old_size;
- u64 devid = 1;
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_ioctl_vol_args *vol_args;
- struct btrfs_trans_handle *trans;
- struct btrfs_device *device = NULL;
- char *sizestr;
- char *retptr;
- char *devstr = NULL;
- int ret = 0;
- int mod = 0;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_RESIZE)) {
- mnt_drop_write_file(file);
- return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- }
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args)) {
- ret = PTR_ERR(vol_args);
- goto out;
- }
- vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
- sizestr = vol_args->name;
- devstr = strchr(sizestr, ':');
- if (devstr) {
- sizestr = devstr + 1;
- *devstr = '\0';
- devstr = vol_args->name;
- ret = kstrtoull(devstr, 10, &devid);
- if (ret)
- goto out_free;
- if (!devid) {
- ret = -EINVAL;
- goto out_free;
- }
- btrfs_info(fs_info, "resizing devid %llu", devid);
- }
- device = btrfs_find_device(fs_info->fs_devices, devid, NULL, NULL, true);
- if (!device) {
- btrfs_info(fs_info, "resizer unable to find device %llu",
- devid);
- ret = -ENODEV;
- goto out_free;
- }
- if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) {
- btrfs_info(fs_info,
- "resizer unable to apply on readonly device %llu",
- devid);
- ret = -EPERM;
- goto out_free;
- }
- if (!strcmp(sizestr, "max"))
- new_size = device->bdev->bd_inode->i_size;
- else {
- if (sizestr[0] == '-') {
- mod = -1;
- sizestr++;
- } else if (sizestr[0] == '+') {
- mod = 1;
- sizestr++;
- }
- new_size = memparse(sizestr, &retptr);
- if (*retptr != '\0' || new_size == 0) {
- ret = -EINVAL;
- goto out_free;
- }
- }
- if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) {
- ret = -EPERM;
- goto out_free;
- }
- old_size = btrfs_device_get_total_bytes(device);
- if (mod < 0) {
- if (new_size > old_size) {
- ret = -EINVAL;
- goto out_free;
- }
- new_size = old_size - new_size;
- } else if (mod > 0) {
- if (new_size > ULLONG_MAX - old_size) {
- ret = -ERANGE;
- goto out_free;
- }
- new_size = old_size + new_size;
- }
- if (new_size < SZ_256M) {
- ret = -EINVAL;
- goto out_free;
- }
- if (new_size > device->bdev->bd_inode->i_size) {
- ret = -EFBIG;
- goto out_free;
- }
- new_size = round_down(new_size, fs_info->sectorsize);
- if (new_size > old_size) {
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_free;
- }
- ret = btrfs_grow_device(trans, device, new_size);
- btrfs_commit_transaction(trans);
- } else if (new_size < old_size) {
- ret = btrfs_shrink_device(device, new_size);
- } /* equal, nothing need to do */
- if (ret == 0 && new_size != old_size)
- btrfs_info_in_rcu(fs_info,
- "resize device %s (devid %llu) from %llu to %llu",
- rcu_str_deref(device->name), device->devid,
- old_size, new_size);
- out_free:
- kfree(vol_args);
- out:
- btrfs_exclop_finish(fs_info);
- mnt_drop_write_file(file);
- return ret;
- }
- static noinline int __btrfs_ioctl_snap_create(struct file *file,
- const char *name, unsigned long fd, int subvol,
- bool readonly,
- struct btrfs_qgroup_inherit *inherit)
- {
- int namelen;
- int ret = 0;
- if (!S_ISDIR(file_inode(file)->i_mode))
- return -ENOTDIR;
- ret = mnt_want_write_file(file);
- if (ret)
- goto out;
- namelen = strlen(name);
- if (strchr(name, '/')) {
- ret = -EINVAL;
- goto out_drop_write;
- }
- if (name[0] == '.' &&
- (namelen == 1 || (name[1] == '.' && namelen == 2))) {
- ret = -EEXIST;
- goto out_drop_write;
- }
- if (subvol) {
- ret = btrfs_mksubvol(&file->f_path, name, namelen,
- NULL, readonly, inherit);
- } else {
- struct fd src = fdget(fd);
- struct inode *src_inode;
- if (!src.file) {
- ret = -EINVAL;
- goto out_drop_write;
- }
- src_inode = file_inode(src.file);
- if (src_inode->i_sb != file_inode(file)->i_sb) {
- btrfs_info(BTRFS_I(file_inode(file))->root->fs_info,
- "Snapshot src from another FS");
- ret = -EXDEV;
- } else if (!inode_owner_or_capable(src_inode)) {
- /*
- * Subvolume creation is not restricted, but snapshots
- * are limited to own subvolumes only
- */
- ret = -EPERM;
- } else {
- ret = btrfs_mksnapshot(&file->f_path, name, namelen,
- BTRFS_I(src_inode)->root,
- readonly, inherit);
- }
- fdput(src);
- }
- out_drop_write:
- mnt_drop_write_file(file);
- out:
- return ret;
- }
- static noinline int btrfs_ioctl_snap_create(struct file *file,
- void __user *arg, int subvol)
- {
- struct btrfs_ioctl_vol_args *vol_args;
- int ret;
- if (!S_ISDIR(file_inode(file)->i_mode))
- return -ENOTDIR;
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args))
- return PTR_ERR(vol_args);
- vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
- ret = __btrfs_ioctl_snap_create(file, vol_args->name, vol_args->fd,
- subvol, false, NULL);
- kfree(vol_args);
- return ret;
- }
- static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
- void __user *arg, int subvol)
- {
- struct btrfs_ioctl_vol_args_v2 *vol_args;
- int ret;
- bool readonly = false;
- struct btrfs_qgroup_inherit *inherit = NULL;
- if (!S_ISDIR(file_inode(file)->i_mode))
- return -ENOTDIR;
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args))
- return PTR_ERR(vol_args);
- vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
- if (vol_args->flags & ~BTRFS_SUBVOL_CREATE_ARGS_MASK) {
- ret = -EOPNOTSUPP;
- goto free_args;
- }
- if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
- readonly = true;
- if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
- u64 nums;
- if (vol_args->size < sizeof(*inherit) ||
- vol_args->size > PAGE_SIZE) {
- ret = -EINVAL;
- goto free_args;
- }
- inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size);
- if (IS_ERR(inherit)) {
- ret = PTR_ERR(inherit);
- goto free_args;
- }
- if (inherit->num_qgroups > PAGE_SIZE ||
- inherit->num_ref_copies > PAGE_SIZE ||
- inherit->num_excl_copies > PAGE_SIZE) {
- ret = -EINVAL;
- goto free_inherit;
- }
- nums = inherit->num_qgroups + 2 * inherit->num_ref_copies +
- 2 * inherit->num_excl_copies;
- if (vol_args->size != struct_size(inherit, qgroups, nums)) {
- ret = -EINVAL;
- goto free_inherit;
- }
- }
- ret = __btrfs_ioctl_snap_create(file, vol_args->name, vol_args->fd,
- subvol, readonly, inherit);
- if (ret)
- goto free_inherit;
- free_inherit:
- kfree(inherit);
- free_args:
- kfree(vol_args);
- return ret;
- }
- static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
- void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- int ret = 0;
- u64 flags = 0;
- if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID)
- return -EINVAL;
- down_read(&fs_info->subvol_sem);
- if (btrfs_root_readonly(root))
- flags |= BTRFS_SUBVOL_RDONLY;
- up_read(&fs_info->subvol_sem);
- if (copy_to_user(arg, &flags, sizeof(flags)))
- ret = -EFAULT;
- return ret;
- }
- static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
- void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_trans_handle *trans;
- u64 root_flags;
- u64 flags;
- int ret = 0;
- if (!inode_owner_or_capable(inode))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- goto out;
- if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
- ret = -EINVAL;
- goto out_drop_write;
- }
- if (copy_from_user(&flags, arg, sizeof(flags))) {
- ret = -EFAULT;
- goto out_drop_write;
- }
- if (flags & ~BTRFS_SUBVOL_RDONLY) {
- ret = -EOPNOTSUPP;
- goto out_drop_write;
- }
- down_write(&fs_info->subvol_sem);
- /* nothing to do */
- if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
- goto out_drop_sem;
- root_flags = btrfs_root_flags(&root->root_item);
- if (flags & BTRFS_SUBVOL_RDONLY) {
- btrfs_set_root_flags(&root->root_item,
- root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
- } else {
- /*
- * Block RO -> RW transition if this subvolume is involved in
- * send
- */
- spin_lock(&root->root_item_lock);
- if (root->send_in_progress == 0) {
- btrfs_set_root_flags(&root->root_item,
- root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
- spin_unlock(&root->root_item_lock);
- } else {
- spin_unlock(&root->root_item_lock);
- btrfs_warn(fs_info,
- "Attempt to set subvolume %llu read-write during send",
- root->root_key.objectid);
- ret = -EPERM;
- goto out_drop_sem;
- }
- }
- trans = btrfs_start_transaction(root, 1);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_reset;
- }
- ret = btrfs_update_root(trans, fs_info->tree_root,
- &root->root_key, &root->root_item);
- if (ret < 0) {
- btrfs_end_transaction(trans);
- goto out_reset;
- }
- ret = btrfs_commit_transaction(trans);
- out_reset:
- if (ret)
- btrfs_set_root_flags(&root->root_item, root_flags);
- out_drop_sem:
- up_write(&fs_info->subvol_sem);
- out_drop_write:
- mnt_drop_write_file(file);
- out:
- return ret;
- }
- static noinline int key_in_sk(struct btrfs_key *key,
- struct btrfs_ioctl_search_key *sk)
- {
- struct btrfs_key test;
- int ret;
- test.objectid = sk->min_objectid;
- test.type = sk->min_type;
- test.offset = sk->min_offset;
- ret = btrfs_comp_cpu_keys(key, &test);
- if (ret < 0)
- return 0;
- test.objectid = sk->max_objectid;
- test.type = sk->max_type;
- test.offset = sk->max_offset;
- ret = btrfs_comp_cpu_keys(key, &test);
- if (ret > 0)
- return 0;
- return 1;
- }
- static noinline int copy_to_sk(struct btrfs_path *path,
- struct btrfs_key *key,
- struct btrfs_ioctl_search_key *sk,
- size_t *buf_size,
- char __user *ubuf,
- unsigned long *sk_offset,
- int *num_found)
- {
- u64 found_transid;
- struct extent_buffer *leaf;
- struct btrfs_ioctl_search_header sh;
- struct btrfs_key test;
- unsigned long item_off;
- unsigned long item_len;
- int nritems;
- int i;
- int slot;
- int ret = 0;
- leaf = path->nodes[0];
- slot = path->slots[0];
- nritems = btrfs_header_nritems(leaf);
- if (btrfs_header_generation(leaf) > sk->max_transid) {
- i = nritems;
- goto advance_key;
- }
- found_transid = btrfs_header_generation(leaf);
- for (i = slot; i < nritems; i++) {
- item_off = btrfs_item_ptr_offset(leaf, i);
- item_len = btrfs_item_size_nr(leaf, i);
- btrfs_item_key_to_cpu(leaf, key, i);
- if (!key_in_sk(key, sk))
- continue;
- if (sizeof(sh) + item_len > *buf_size) {
- if (*num_found) {
- ret = 1;
- goto out;
- }
- /*
- * return one empty item back for v1, which does not
- * handle -EOVERFLOW
- */
- *buf_size = sizeof(sh) + item_len;
- item_len = 0;
- ret = -EOVERFLOW;
- }
- if (sizeof(sh) + item_len + *sk_offset > *buf_size) {
- ret = 1;
- goto out;
- }
- sh.objectid = key->objectid;
- sh.offset = key->offset;
- sh.type = key->type;
- sh.len = item_len;
- sh.transid = found_transid;
- /*
- * Copy search result header. If we fault then loop again so we
- * can fault in the pages and -EFAULT there if there's a
- * problem. Otherwise we'll fault and then copy the buffer in
- * properly this next time through
- */
- if (copy_to_user_nofault(ubuf + *sk_offset, &sh, sizeof(sh))) {
- ret = 0;
- goto out;
- }
- *sk_offset += sizeof(sh);
- if (item_len) {
- char __user *up = ubuf + *sk_offset;
- /*
- * Copy the item, same behavior as above, but reset the
- * * sk_offset so we copy the full thing again.
- */
- if (read_extent_buffer_to_user_nofault(leaf, up,
- item_off, item_len)) {
- ret = 0;
- *sk_offset -= sizeof(sh);
- goto out;
- }
- *sk_offset += item_len;
- }
- (*num_found)++;
- if (ret) /* -EOVERFLOW from above */
- goto out;
- if (*num_found >= sk->nr_items) {
- ret = 1;
- goto out;
- }
- }
- advance_key:
- ret = 0;
- test.objectid = sk->max_objectid;
- test.type = sk->max_type;
- test.offset = sk->max_offset;
- if (btrfs_comp_cpu_keys(key, &test) >= 0)
- ret = 1;
- else if (key->offset < (u64)-1)
- key->offset++;
- else if (key->type < (u8)-1) {
- key->offset = 0;
- key->type++;
- } else if (key->objectid < (u64)-1) {
- key->offset = 0;
- key->type = 0;
- key->objectid++;
- } else
- ret = 1;
- out:
- /*
- * 0: all items from this leaf copied, continue with next
- * 1: * more items can be copied, but unused buffer is too small
- * * all items were found
- * Either way, it will stops the loop which iterates to the next
- * leaf
- * -EOVERFLOW: item was to large for buffer
- * -EFAULT: could not copy extent buffer back to userspace
- */
- return ret;
- }
- static noinline int search_ioctl(struct inode *inode,
- struct btrfs_ioctl_search_key *sk,
- size_t *buf_size,
- char __user *ubuf)
- {
- struct btrfs_fs_info *info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root;
- struct btrfs_key key;
- struct btrfs_path *path;
- int ret;
- int num_found = 0;
- unsigned long sk_offset = 0;
- if (*buf_size < sizeof(struct btrfs_ioctl_search_header)) {
- *buf_size = sizeof(struct btrfs_ioctl_search_header);
- return -EOVERFLOW;
- }
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- if (sk->tree_id == 0) {
- /* search the root of the inode that was passed */
- root = btrfs_grab_root(BTRFS_I(inode)->root);
- } else {
- root = btrfs_get_fs_root(info, sk->tree_id, true);
- if (IS_ERR(root)) {
- btrfs_free_path(path);
- return PTR_ERR(root);
- }
- }
- key.objectid = sk->min_objectid;
- key.type = sk->min_type;
- key.offset = sk->min_offset;
- while (1) {
- ret = fault_in_pages_writeable(ubuf + sk_offset,
- *buf_size - sk_offset);
- if (ret)
- break;
- ret = btrfs_search_forward(root, &key, path, sk->min_transid);
- if (ret != 0) {
- if (ret > 0)
- ret = 0;
- goto err;
- }
- ret = copy_to_sk(path, &key, sk, buf_size, ubuf,
- &sk_offset, &num_found);
- btrfs_release_path(path);
- if (ret)
- break;
- }
- if (ret > 0)
- ret = 0;
- err:
- sk->nr_items = num_found;
- btrfs_put_root(root);
- btrfs_free_path(path);
- return ret;
- }
- static noinline int btrfs_ioctl_tree_search(struct file *file,
- void __user *argp)
- {
- struct btrfs_ioctl_search_args __user *uargs;
- struct btrfs_ioctl_search_key sk;
- struct inode *inode;
- int ret;
- size_t buf_size;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- uargs = (struct btrfs_ioctl_search_args __user *)argp;
- if (copy_from_user(&sk, &uargs->key, sizeof(sk)))
- return -EFAULT;
- buf_size = sizeof(uargs->buf);
- inode = file_inode(file);
- ret = search_ioctl(inode, &sk, &buf_size, uargs->buf);
- /*
- * In the origin implementation an overflow is handled by returning a
- * search header with a len of zero, so reset ret.
- */
- if (ret == -EOVERFLOW)
- ret = 0;
- if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk)))
- ret = -EFAULT;
- return ret;
- }
- static noinline int btrfs_ioctl_tree_search_v2(struct file *file,
- void __user *argp)
- {
- struct btrfs_ioctl_search_args_v2 __user *uarg;
- struct btrfs_ioctl_search_args_v2 args;
- struct inode *inode;
- int ret;
- size_t buf_size;
- const size_t buf_limit = SZ_16M;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- /* copy search header and buffer size */
- uarg = (struct btrfs_ioctl_search_args_v2 __user *)argp;
- if (copy_from_user(&args, uarg, sizeof(args)))
- return -EFAULT;
- buf_size = args.buf_size;
- /* limit result size to 16MB */
- if (buf_size > buf_limit)
- buf_size = buf_limit;
- inode = file_inode(file);
- ret = search_ioctl(inode, &args.key, &buf_size,
- (char __user *)(&uarg->buf[0]));
- if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key)))
- ret = -EFAULT;
- else if (ret == -EOVERFLOW &&
- copy_to_user(&uarg->buf_size, &buf_size, sizeof(buf_size)))
- ret = -EFAULT;
- return ret;
- }
- /*
- * Search INODE_REFs to identify path name of 'dirid' directory
- * in a 'tree_id' tree. and sets path name to 'name'.
- */
- static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
- u64 tree_id, u64 dirid, char *name)
- {
- struct btrfs_root *root;
- struct btrfs_key key;
- char *ptr;
- int ret = -1;
- int slot;
- int len;
- int total_len = 0;
- struct btrfs_inode_ref *iref;
- struct extent_buffer *l;
- struct btrfs_path *path;
- if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
- name[0]='\0';
- return 0;
- }
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1];
- root = btrfs_get_fs_root(info, tree_id, true);
- if (IS_ERR(root)) {
- ret = PTR_ERR(root);
- root = NULL;
- goto out;
- }
- key.objectid = dirid;
- key.type = BTRFS_INODE_REF_KEY;
- key.offset = (u64)-1;
- while (1) {
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0)
- goto out;
- else if (ret > 0) {
- ret = btrfs_previous_item(root, path, dirid,
- BTRFS_INODE_REF_KEY);
- if (ret < 0)
- goto out;
- else if (ret > 0) {
- ret = -ENOENT;
- goto out;
- }
- }
- l = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(l, &key, slot);
- iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
- len = btrfs_inode_ref_name_len(l, iref);
- ptr -= len + 1;
- total_len += len + 1;
- if (ptr < name) {
- ret = -ENAMETOOLONG;
- goto out;
- }
- *(ptr + len) = '/';
- read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len);
- if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
- break;
- btrfs_release_path(path);
- key.objectid = key.offset;
- key.offset = (u64)-1;
- dirid = key.objectid;
- }
- memmove(name, ptr, total_len);
- name[total_len] = '\0';
- ret = 0;
- out:
- btrfs_put_root(root);
- btrfs_free_path(path);
- return ret;
- }
- static int btrfs_search_path_in_tree_user(struct inode *inode,
- struct btrfs_ioctl_ino_lookup_user_args *args)
- {
- struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
- struct super_block *sb = inode->i_sb;
- struct btrfs_key upper_limit = BTRFS_I(inode)->location;
- u64 treeid = BTRFS_I(inode)->root->root_key.objectid;
- u64 dirid = args->dirid;
- unsigned long item_off;
- unsigned long item_len;
- struct btrfs_inode_ref *iref;
- struct btrfs_root_ref *rref;
- struct btrfs_root *root = NULL;
- struct btrfs_path *path;
- struct btrfs_key key, key2;
- struct extent_buffer *leaf;
- struct inode *temp_inode;
- char *ptr;
- int slot;
- int len;
- int total_len = 0;
- int ret;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- /*
- * If the bottom subvolume does not exist directly under upper_limit,
- * construct the path in from the bottom up.
- */
- if (dirid != upper_limit.objectid) {
- ptr = &args->path[BTRFS_INO_LOOKUP_USER_PATH_MAX - 1];
- root = btrfs_get_fs_root(fs_info, treeid, true);
- if (IS_ERR(root)) {
- ret = PTR_ERR(root);
- goto out;
- }
- key.objectid = dirid;
- key.type = BTRFS_INODE_REF_KEY;
- key.offset = (u64)-1;
- while (1) {
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0) {
- goto out_put;
- } else if (ret > 0) {
- ret = btrfs_previous_item(root, path, dirid,
- BTRFS_INODE_REF_KEY);
- if (ret < 0) {
- goto out_put;
- } else if (ret > 0) {
- ret = -ENOENT;
- goto out_put;
- }
- }
- leaf = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(leaf, &key, slot);
- iref = btrfs_item_ptr(leaf, slot, struct btrfs_inode_ref);
- len = btrfs_inode_ref_name_len(leaf, iref);
- ptr -= len + 1;
- total_len += len + 1;
- if (ptr < args->path) {
- ret = -ENAMETOOLONG;
- goto out_put;
- }
- *(ptr + len) = '/';
- read_extent_buffer(leaf, ptr,
- (unsigned long)(iref + 1), len);
- /* Check the read+exec permission of this directory */
- ret = btrfs_previous_item(root, path, dirid,
- BTRFS_INODE_ITEM_KEY);
- if (ret < 0) {
- goto out_put;
- } else if (ret > 0) {
- ret = -ENOENT;
- goto out_put;
- }
- leaf = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(leaf, &key2, slot);
- if (key2.objectid != dirid) {
- ret = -ENOENT;
- goto out_put;
- }
- temp_inode = btrfs_iget(sb, key2.objectid, root);
- if (IS_ERR(temp_inode)) {
- ret = PTR_ERR(temp_inode);
- goto out_put;
- }
- ret = inode_permission(temp_inode, MAY_READ | MAY_EXEC);
- iput(temp_inode);
- if (ret) {
- ret = -EACCES;
- goto out_put;
- }
- if (key.offset == upper_limit.objectid)
- break;
- if (key.objectid == BTRFS_FIRST_FREE_OBJECTID) {
- ret = -EACCES;
- goto out_put;
- }
- btrfs_release_path(path);
- key.objectid = key.offset;
- key.offset = (u64)-1;
- dirid = key.objectid;
- }
- memmove(args->path, ptr, total_len);
- args->path[total_len] = '\0';
- btrfs_put_root(root);
- root = NULL;
- btrfs_release_path(path);
- }
- /* Get the bottom subvolume's name from ROOT_REF */
- key.objectid = treeid;
- key.type = BTRFS_ROOT_REF_KEY;
- key.offset = args->treeid;
- ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
- if (ret < 0) {
- goto out;
- } else if (ret > 0) {
- ret = -ENOENT;
- goto out;
- }
- leaf = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(leaf, &key, slot);
- item_off = btrfs_item_ptr_offset(leaf, slot);
- item_len = btrfs_item_size_nr(leaf, slot);
- /* Check if dirid in ROOT_REF corresponds to passed dirid */
- rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
- if (args->dirid != btrfs_root_ref_dirid(leaf, rref)) {
- ret = -EINVAL;
- goto out;
- }
- /* Copy subvolume's name */
- item_off += sizeof(struct btrfs_root_ref);
- item_len -= sizeof(struct btrfs_root_ref);
- read_extent_buffer(leaf, args->name, item_off, item_len);
- args->name[item_len] = 0;
- out_put:
- btrfs_put_root(root);
- out:
- btrfs_free_path(path);
- return ret;
- }
- static noinline int btrfs_ioctl_ino_lookup(struct file *file,
- void __user *argp)
- {
- struct btrfs_ioctl_ino_lookup_args *args;
- struct inode *inode;
- int ret = 0;
- args = memdup_user(argp, sizeof(*args));
- if (IS_ERR(args))
- return PTR_ERR(args);
- inode = file_inode(file);
- /*
- * Unprivileged query to obtain the containing subvolume root id. The
- * path is reset so it's consistent with btrfs_search_path_in_tree.
- */
- if (args->treeid == 0)
- args->treeid = BTRFS_I(inode)->root->root_key.objectid;
- if (args->objectid == BTRFS_FIRST_FREE_OBJECTID) {
- args->name[0] = 0;
- goto out;
- }
- if (!capable(CAP_SYS_ADMIN)) {
- ret = -EPERM;
- goto out;
- }
- ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
- args->treeid, args->objectid,
- args->name);
- out:
- if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
- ret = -EFAULT;
- kfree(args);
- return ret;
- }
- /*
- * Version of ino_lookup ioctl (unprivileged)
- *
- * The main differences from ino_lookup ioctl are:
- *
- * 1. Read + Exec permission will be checked using inode_permission() during
- * path construction. -EACCES will be returned in case of failure.
- * 2. Path construction will be stopped at the inode number which corresponds
- * to the fd with which this ioctl is called. If constructed path does not
- * exist under fd's inode, -EACCES will be returned.
- * 3. The name of bottom subvolume is also searched and filled.
- */
- static int btrfs_ioctl_ino_lookup_user(struct file *file, void __user *argp)
- {
- struct btrfs_ioctl_ino_lookup_user_args *args;
- struct inode *inode;
- int ret;
- args = memdup_user(argp, sizeof(*args));
- if (IS_ERR(args))
- return PTR_ERR(args);
- inode = file_inode(file);
- if (args->dirid == BTRFS_FIRST_FREE_OBJECTID &&
- BTRFS_I(inode)->location.objectid != BTRFS_FIRST_FREE_OBJECTID) {
- /*
- * The subvolume does not exist under fd with which this is
- * called
- */
- kfree(args);
- return -EACCES;
- }
- ret = btrfs_search_path_in_tree_user(inode, args);
- if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
- ret = -EFAULT;
- kfree(args);
- return ret;
- }
- /* Get the subvolume information in BTRFS_ROOT_ITEM and BTRFS_ROOT_BACKREF */
- static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp)
- {
- struct btrfs_ioctl_get_subvol_info_args *subvol_info;
- struct btrfs_fs_info *fs_info;
- struct btrfs_root *root;
- struct btrfs_path *path;
- struct btrfs_key key;
- struct btrfs_root_item *root_item;
- struct btrfs_root_ref *rref;
- struct extent_buffer *leaf;
- unsigned long item_off;
- unsigned long item_len;
- struct inode *inode;
- int slot;
- int ret = 0;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- subvol_info = kzalloc(sizeof(*subvol_info), GFP_KERNEL);
- if (!subvol_info) {
- btrfs_free_path(path);
- return -ENOMEM;
- }
- inode = file_inode(file);
- fs_info = BTRFS_I(inode)->root->fs_info;
- /* Get root_item of inode's subvolume */
- key.objectid = BTRFS_I(inode)->root->root_key.objectid;
- root = btrfs_get_fs_root(fs_info, key.objectid, true);
- if (IS_ERR(root)) {
- ret = PTR_ERR(root);
- goto out_free;
- }
- root_item = &root->root_item;
- subvol_info->treeid = key.objectid;
- subvol_info->generation = btrfs_root_generation(root_item);
- subvol_info->flags = btrfs_root_flags(root_item);
- memcpy(subvol_info->uuid, root_item->uuid, BTRFS_UUID_SIZE);
- memcpy(subvol_info->parent_uuid, root_item->parent_uuid,
- BTRFS_UUID_SIZE);
- memcpy(subvol_info->received_uuid, root_item->received_uuid,
- BTRFS_UUID_SIZE);
- subvol_info->ctransid = btrfs_root_ctransid(root_item);
- subvol_info->ctime.sec = btrfs_stack_timespec_sec(&root_item->ctime);
- subvol_info->ctime.nsec = btrfs_stack_timespec_nsec(&root_item->ctime);
- subvol_info->otransid = btrfs_root_otransid(root_item);
- subvol_info->otime.sec = btrfs_stack_timespec_sec(&root_item->otime);
- subvol_info->otime.nsec = btrfs_stack_timespec_nsec(&root_item->otime);
- subvol_info->stransid = btrfs_root_stransid(root_item);
- subvol_info->stime.sec = btrfs_stack_timespec_sec(&root_item->stime);
- subvol_info->stime.nsec = btrfs_stack_timespec_nsec(&root_item->stime);
- subvol_info->rtransid = btrfs_root_rtransid(root_item);
- subvol_info->rtime.sec = btrfs_stack_timespec_sec(&root_item->rtime);
- subvol_info->rtime.nsec = btrfs_stack_timespec_nsec(&root_item->rtime);
- if (key.objectid != BTRFS_FS_TREE_OBJECTID) {
- /* Search root tree for ROOT_BACKREF of this subvolume */
- key.type = BTRFS_ROOT_BACKREF_KEY;
- key.offset = 0;
- ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
- if (ret < 0) {
- goto out;
- } else if (path->slots[0] >=
- btrfs_header_nritems(path->nodes[0])) {
- ret = btrfs_next_leaf(fs_info->tree_root, path);
- if (ret < 0) {
- goto out;
- } else if (ret > 0) {
- ret = -EUCLEAN;
- goto out;
- }
- }
- leaf = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(leaf, &key, slot);
- if (key.objectid == subvol_info->treeid &&
- key.type == BTRFS_ROOT_BACKREF_KEY) {
- subvol_info->parent_id = key.offset;
- rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
- subvol_info->dirid = btrfs_root_ref_dirid(leaf, rref);
- item_off = btrfs_item_ptr_offset(leaf, slot)
- + sizeof(struct btrfs_root_ref);
- item_len = btrfs_item_size_nr(leaf, slot)
- - sizeof(struct btrfs_root_ref);
- read_extent_buffer(leaf, subvol_info->name,
- item_off, item_len);
- } else {
- ret = -ENOENT;
- goto out;
- }
- }
- if (copy_to_user(argp, subvol_info, sizeof(*subvol_info)))
- ret = -EFAULT;
- out:
- btrfs_put_root(root);
- out_free:
- btrfs_free_path(path);
- kfree(subvol_info);
- return ret;
- }
- /*
- * Return ROOT_REF information of the subvolume containing this inode
- * except the subvolume name.
- */
- static int btrfs_ioctl_get_subvol_rootref(struct file *file, void __user *argp)
- {
- struct btrfs_ioctl_get_subvol_rootref_args *rootrefs;
- struct btrfs_root_ref *rref;
- struct btrfs_root *root;
- struct btrfs_path *path;
- struct btrfs_key key;
- struct extent_buffer *leaf;
- struct inode *inode;
- u64 objectid;
- int slot;
- int ret;
- u8 found;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- rootrefs = memdup_user(argp, sizeof(*rootrefs));
- if (IS_ERR(rootrefs)) {
- btrfs_free_path(path);
- return PTR_ERR(rootrefs);
- }
- inode = file_inode(file);
- root = BTRFS_I(inode)->root->fs_info->tree_root;
- objectid = BTRFS_I(inode)->root->root_key.objectid;
- key.objectid = objectid;
- key.type = BTRFS_ROOT_REF_KEY;
- key.offset = rootrefs->min_treeid;
- found = 0;
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0) {
- goto out;
- } else if (path->slots[0] >=
- btrfs_header_nritems(path->nodes[0])) {
- ret = btrfs_next_leaf(root, path);
- if (ret < 0) {
- goto out;
- } else if (ret > 0) {
- ret = -EUCLEAN;
- goto out;
- }
- }
- while (1) {
- leaf = path->nodes[0];
- slot = path->slots[0];
- btrfs_item_key_to_cpu(leaf, &key, slot);
- if (key.objectid != objectid || key.type != BTRFS_ROOT_REF_KEY) {
- ret = 0;
- goto out;
- }
- if (found == BTRFS_MAX_ROOTREF_BUFFER_NUM) {
- ret = -EOVERFLOW;
- goto out;
- }
- rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
- rootrefs->rootref[found].treeid = key.offset;
- rootrefs->rootref[found].dirid =
- btrfs_root_ref_dirid(leaf, rref);
- found++;
- ret = btrfs_next_item(root, path);
- if (ret < 0) {
- goto out;
- } else if (ret > 0) {
- ret = -EUCLEAN;
- goto out;
- }
- }
- out:
- if (!ret || ret == -EOVERFLOW) {
- rootrefs->num_items = found;
- /* update min_treeid for next search */
- if (found)
- rootrefs->min_treeid =
- rootrefs->rootref[found - 1].treeid + 1;
- if (copy_to_user(argp, rootrefs, sizeof(*rootrefs)))
- ret = -EFAULT;
- }
- kfree(rootrefs);
- btrfs_free_path(path);
- return ret;
- }
- static noinline int btrfs_ioctl_snap_destroy(struct file *file,
- void __user *arg,
- bool destroy_v2)
- {
- struct dentry *parent = file->f_path.dentry;
- struct btrfs_fs_info *fs_info = btrfs_sb(parent->d_sb);
- struct dentry *dentry;
- struct inode *dir = d_inode(parent);
- struct inode *inode;
- struct btrfs_root *root = BTRFS_I(dir)->root;
- struct btrfs_root *dest = NULL;
- struct btrfs_ioctl_vol_args *vol_args = NULL;
- struct btrfs_ioctl_vol_args_v2 *vol_args2 = NULL;
- char *subvol_name, *subvol_name_ptr = NULL;
- int subvol_namelen;
- int err = 0;
- bool destroy_parent = false;
- if (destroy_v2) {
- vol_args2 = memdup_user(arg, sizeof(*vol_args2));
- if (IS_ERR(vol_args2))
- return PTR_ERR(vol_args2);
- if (vol_args2->flags & ~BTRFS_SUBVOL_DELETE_ARGS_MASK) {
- err = -EOPNOTSUPP;
- goto out;
- }
- /*
- * If SPEC_BY_ID is not set, we are looking for the subvolume by
- * name, same as v1 currently does.
- */
- if (!(vol_args2->flags & BTRFS_SUBVOL_SPEC_BY_ID)) {
- vol_args2->name[BTRFS_SUBVOL_NAME_MAX] = 0;
- subvol_name = vol_args2->name;
- err = mnt_want_write_file(file);
- if (err)
- goto out;
- } else {
- if (vol_args2->subvolid < BTRFS_FIRST_FREE_OBJECTID) {
- err = -EINVAL;
- goto out;
- }
- err = mnt_want_write_file(file);
- if (err)
- goto out;
- dentry = btrfs_get_dentry(fs_info->sb,
- BTRFS_FIRST_FREE_OBJECTID,
- vol_args2->subvolid, 0, 0);
- if (IS_ERR(dentry)) {
- err = PTR_ERR(dentry);
- goto out_drop_write;
- }
- /*
- * Change the default parent since the subvolume being
- * deleted can be outside of the current mount point.
- */
- parent = btrfs_get_parent(dentry);
- /*
- * At this point dentry->d_name can point to '/' if the
- * subvolume we want to destroy is outsite of the
- * current mount point, so we need to release the
- * current dentry and execute the lookup to return a new
- * one with ->d_name pointing to the
- * <mount point>/subvol_name.
- */
- dput(dentry);
- if (IS_ERR(parent)) {
- err = PTR_ERR(parent);
- goto out_drop_write;
- }
- dir = d_inode(parent);
- /*
- * If v2 was used with SPEC_BY_ID, a new parent was
- * allocated since the subvolume can be outside of the
- * current mount point. Later on we need to release this
- * new parent dentry.
- */
- destroy_parent = true;
- subvol_name_ptr = btrfs_get_subvol_name_from_objectid(
- fs_info, vol_args2->subvolid);
- if (IS_ERR(subvol_name_ptr)) {
- err = PTR_ERR(subvol_name_ptr);
- goto free_parent;
- }
- /* subvol_name_ptr is already NULL termined */
- subvol_name = (char *)kbasename(subvol_name_ptr);
- }
- } else {
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args))
- return PTR_ERR(vol_args);
- vol_args->name[BTRFS_PATH_NAME_MAX] = 0;
- subvol_name = vol_args->name;
- err = mnt_want_write_file(file);
- if (err)
- goto out;
- }
- subvol_namelen = strlen(subvol_name);
- if (strchr(subvol_name, '/') ||
- strncmp(subvol_name, "..", subvol_namelen) == 0) {
- err = -EINVAL;
- goto free_subvol_name;
- }
- if (!S_ISDIR(dir->i_mode)) {
- err = -ENOTDIR;
- goto free_subvol_name;
- }
- err = down_write_killable_nested(&dir->i_rwsem, I_MUTEX_PARENT);
- if (err == -EINTR)
- goto free_subvol_name;
- dentry = lookup_one_len(subvol_name, parent, subvol_namelen);
- if (IS_ERR(dentry)) {
- err = PTR_ERR(dentry);
- goto out_unlock_dir;
- }
- if (d_really_is_negative(dentry)) {
- err = -ENOENT;
- goto out_dput;
- }
- inode = d_inode(dentry);
- dest = BTRFS_I(inode)->root;
- if (!capable(CAP_SYS_ADMIN)) {
- /*
- * Regular user. Only allow this with a special mount
- * option, when the user has write+exec access to the
- * subvol root, and when rmdir(2) would have been
- * allowed.
- *
- * Note that this is _not_ check that the subvol is
- * empty or doesn't contain data that we wouldn't
- * otherwise be able to delete.
- *
- * Users who want to delete empty subvols should try
- * rmdir(2).
- */
- err = -EPERM;
- if (!btrfs_test_opt(fs_info, USER_SUBVOL_RM_ALLOWED))
- goto out_dput;
- /*
- * Do not allow deletion if the parent dir is the same
- * as the dir to be deleted. That means the ioctl
- * must be called on the dentry referencing the root
- * of the subvol, not a random directory contained
- * within it.
- */
- err = -EINVAL;
- if (root == dest)
- goto out_dput;
- err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
- if (err)
- goto out_dput;
- }
- /* check if subvolume may be deleted by a user */
- err = btrfs_may_delete(dir, dentry, 1);
- if (err)
- goto out_dput;
- if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
- err = -EINVAL;
- goto out_dput;
- }
- inode_lock(inode);
- err = btrfs_delete_subvolume(dir, dentry);
- inode_unlock(inode);
- if (!err)
- d_delete_notify(dir, dentry);
- out_dput:
- dput(dentry);
- out_unlock_dir:
- inode_unlock(dir);
- free_subvol_name:
- kfree(subvol_name_ptr);
- free_parent:
- if (destroy_parent)
- dput(parent);
- out_drop_write:
- mnt_drop_write_file(file);
- out:
- kfree(vol_args2);
- kfree(vol_args);
- return err;
- }
- static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_ioctl_defrag_range_args *range;
- int ret;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- if (btrfs_root_readonly(root)) {
- ret = -EROFS;
- goto out;
- }
- switch (inode->i_mode & S_IFMT) {
- case S_IFDIR:
- if (!capable(CAP_SYS_ADMIN)) {
- ret = -EPERM;
- goto out;
- }
- ret = btrfs_defrag_root(root);
- break;
- case S_IFREG:
- /*
- * Note that this does not check the file descriptor for write
- * access. This prevents defragmenting executables that are
- * running and allows defrag on files open in read-only mode.
- */
- if (!capable(CAP_SYS_ADMIN) &&
- inode_permission(inode, MAY_WRITE)) {
- ret = -EPERM;
- goto out;
- }
- range = kzalloc(sizeof(*range), GFP_KERNEL);
- if (!range) {
- ret = -ENOMEM;
- goto out;
- }
- if (argp) {
- if (copy_from_user(range, argp,
- sizeof(*range))) {
- ret = -EFAULT;
- kfree(range);
- goto out;
- }
- /* compression requires us to start the IO */
- if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
- range->flags |= BTRFS_DEFRAG_RANGE_START_IO;
- range->extent_thresh = (u32)-1;
- }
- } else {
- /* the rest are all set to zero by kzalloc */
- range->len = (u64)-1;
- }
- ret = btrfs_defrag_file(file_inode(file), file,
- range, BTRFS_OLDEST_GENERATION, 0);
- if (ret > 0)
- ret = 0;
- kfree(range);
- break;
- default:
- ret = -EINVAL;
- }
- out:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_add_dev(struct btrfs_fs_info *fs_info, void __user *arg)
- {
- struct btrfs_ioctl_vol_args *vol_args;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_ADD))
- return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args)) {
- ret = PTR_ERR(vol_args);
- goto out;
- }
- vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
- ret = btrfs_init_new_device(fs_info, vol_args->name);
- if (!ret)
- btrfs_info(fs_info, "disk added %s", vol_args->name);
- kfree(vol_args);
- out:
- btrfs_exclop_finish(fs_info);
- return ret;
- }
- static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_ioctl_vol_args_v2 *vol_args;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args)) {
- ret = PTR_ERR(vol_args);
- goto err_drop;
- }
- if (vol_args->flags & ~BTRFS_DEVICE_REMOVE_ARGS_MASK) {
- ret = -EOPNOTSUPP;
- goto out;
- }
- if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REMOVE)) {
- ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- goto out;
- }
- if (vol_args->flags & BTRFS_DEVICE_SPEC_BY_ID) {
- ret = btrfs_rm_device(fs_info, NULL, vol_args->devid);
- } else {
- vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
- ret = btrfs_rm_device(fs_info, vol_args->name, 0);
- }
- btrfs_exclop_finish(fs_info);
- if (!ret) {
- if (vol_args->flags & BTRFS_DEVICE_SPEC_BY_ID)
- btrfs_info(fs_info, "device deleted: id %llu",
- vol_args->devid);
- else
- btrfs_info(fs_info, "device deleted: %s",
- vol_args->name);
- }
- out:
- kfree(vol_args);
- err_drop:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_ioctl_vol_args *vol_args;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REMOVE)) {
- ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- goto out_drop_write;
- }
- vol_args = memdup_user(arg, sizeof(*vol_args));
- if (IS_ERR(vol_args)) {
- ret = PTR_ERR(vol_args);
- goto out;
- }
- vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
- ret = btrfs_rm_device(fs_info, vol_args->name, 0);
- if (!ret)
- btrfs_info(fs_info, "disk deleted %s", vol_args->name);
- kfree(vol_args);
- out:
- btrfs_exclop_finish(fs_info);
- out_drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_fs_info(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_fs_info_args *fi_args;
- struct btrfs_device *device;
- struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
- u64 flags_in;
- int ret = 0;
- fi_args = memdup_user(arg, sizeof(*fi_args));
- if (IS_ERR(fi_args))
- return PTR_ERR(fi_args);
- flags_in = fi_args->flags;
- memset(fi_args, 0, sizeof(*fi_args));
- rcu_read_lock();
- fi_args->num_devices = fs_devices->num_devices;
- list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
- if (device->devid > fi_args->max_id)
- fi_args->max_id = device->devid;
- }
- rcu_read_unlock();
- memcpy(&fi_args->fsid, fs_devices->fsid, sizeof(fi_args->fsid));
- fi_args->nodesize = fs_info->nodesize;
- fi_args->sectorsize = fs_info->sectorsize;
- fi_args->clone_alignment = fs_info->sectorsize;
- if (flags_in & BTRFS_FS_INFO_FLAG_CSUM_INFO) {
- fi_args->csum_type = btrfs_super_csum_type(fs_info->super_copy);
- fi_args->csum_size = btrfs_super_csum_size(fs_info->super_copy);
- fi_args->flags |= BTRFS_FS_INFO_FLAG_CSUM_INFO;
- }
- if (flags_in & BTRFS_FS_INFO_FLAG_GENERATION) {
- fi_args->generation = fs_info->generation;
- fi_args->flags |= BTRFS_FS_INFO_FLAG_GENERATION;
- }
- if (flags_in & BTRFS_FS_INFO_FLAG_METADATA_UUID) {
- memcpy(&fi_args->metadata_uuid, fs_devices->metadata_uuid,
- sizeof(fi_args->metadata_uuid));
- fi_args->flags |= BTRFS_FS_INFO_FLAG_METADATA_UUID;
- }
- if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
- ret = -EFAULT;
- kfree(fi_args);
- return ret;
- }
- static long btrfs_ioctl_dev_info(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_dev_info_args *di_args;
- struct btrfs_device *dev;
- int ret = 0;
- char *s_uuid = NULL;
- di_args = memdup_user(arg, sizeof(*di_args));
- if (IS_ERR(di_args))
- return PTR_ERR(di_args);
- if (!btrfs_is_empty_uuid(di_args->uuid))
- s_uuid = di_args->uuid;
- rcu_read_lock();
- dev = btrfs_find_device(fs_info->fs_devices, di_args->devid, s_uuid,
- NULL, true);
- if (!dev) {
- ret = -ENODEV;
- goto out;
- }
- di_args->devid = dev->devid;
- di_args->bytes_used = btrfs_device_get_bytes_used(dev);
- di_args->total_bytes = btrfs_device_get_total_bytes(dev);
- memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
- if (dev->name) {
- strncpy(di_args->path, rcu_str_deref(dev->name),
- sizeof(di_args->path) - 1);
- di_args->path[sizeof(di_args->path) - 1] = 0;
- } else {
- di_args->path[0] = '\0';
- }
- out:
- rcu_read_unlock();
- if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
- ret = -EFAULT;
- kfree(di_args);
- return ret;
- }
- static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_root *new_root;
- struct btrfs_dir_item *di;
- struct btrfs_trans_handle *trans;
- struct btrfs_path *path = NULL;
- struct btrfs_disk_key disk_key;
- u64 objectid = 0;
- u64 dir_id;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- if (copy_from_user(&objectid, argp, sizeof(objectid))) {
- ret = -EFAULT;
- goto out;
- }
- if (!objectid)
- objectid = BTRFS_FS_TREE_OBJECTID;
- new_root = btrfs_get_fs_root(fs_info, objectid, true);
- if (IS_ERR(new_root)) {
- ret = PTR_ERR(new_root);
- goto out;
- }
- if (!is_fstree(new_root->root_key.objectid)) {
- ret = -ENOENT;
- goto out_free;
- }
- path = btrfs_alloc_path();
- if (!path) {
- ret = -ENOMEM;
- goto out_free;
- }
- path->leave_spinning = 1;
- trans = btrfs_start_transaction(root, 1);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_free;
- }
- dir_id = btrfs_super_root_dir(fs_info->super_copy);
- di = btrfs_lookup_dir_item(trans, fs_info->tree_root, path,
- dir_id, "default", 7, 1);
- if (IS_ERR_OR_NULL(di)) {
- btrfs_release_path(path);
- btrfs_end_transaction(trans);
- btrfs_err(fs_info,
- "Umm, you don't have the default diritem, this isn't going to work");
- ret = -ENOENT;
- goto out_free;
- }
- btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
- btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
- btrfs_mark_buffer_dirty(path->nodes[0]);
- btrfs_release_path(path);
- btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);
- btrfs_end_transaction(trans);
- out_free:
- btrfs_put_root(new_root);
- btrfs_free_path(path);
- out:
- mnt_drop_write_file(file);
- return ret;
- }
- static void get_block_group_info(struct list_head *groups_list,
- struct btrfs_ioctl_space_info *space)
- {
- struct btrfs_block_group *block_group;
- space->total_bytes = 0;
- space->used_bytes = 0;
- space->flags = 0;
- list_for_each_entry(block_group, groups_list, list) {
- space->flags = block_group->flags;
- space->total_bytes += block_group->length;
- space->used_bytes += block_group->used;
- }
- }
- static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_space_args space_args;
- struct btrfs_ioctl_space_info space;
- struct btrfs_ioctl_space_info *dest;
- struct btrfs_ioctl_space_info *dest_orig;
- struct btrfs_ioctl_space_info __user *user_dest;
- struct btrfs_space_info *info;
- static const u64 types[] = {
- BTRFS_BLOCK_GROUP_DATA,
- BTRFS_BLOCK_GROUP_SYSTEM,
- BTRFS_BLOCK_GROUP_METADATA,
- BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA
- };
- int num_types = 4;
- int alloc_size;
- int ret = 0;
- u64 slot_count = 0;
- int i, c;
- if (copy_from_user(&space_args,
- (struct btrfs_ioctl_space_args __user *)arg,
- sizeof(space_args)))
- return -EFAULT;
- for (i = 0; i < num_types; i++) {
- struct btrfs_space_info *tmp;
- info = NULL;
- list_for_each_entry(tmp, &fs_info->space_info, list) {
- if (tmp->flags == types[i]) {
- info = tmp;
- break;
- }
- }
- if (!info)
- continue;
- down_read(&info->groups_sem);
- for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
- if (!list_empty(&info->block_groups[c]))
- slot_count++;
- }
- up_read(&info->groups_sem);
- }
- /*
- * Global block reserve, exported as a space_info
- */
- slot_count++;
- /* space_slots == 0 means they are asking for a count */
- if (space_args.space_slots == 0) {
- space_args.total_spaces = slot_count;
- goto out;
- }
- slot_count = min_t(u64, space_args.space_slots, slot_count);
- alloc_size = sizeof(*dest) * slot_count;
- /* we generally have at most 6 or so space infos, one for each raid
- * level. So, a whole page should be more than enough for everyone
- */
- if (alloc_size > PAGE_SIZE)
- return -ENOMEM;
- space_args.total_spaces = 0;
- dest = kmalloc(alloc_size, GFP_KERNEL);
- if (!dest)
- return -ENOMEM;
- dest_orig = dest;
- /* now we have a buffer to copy into */
- for (i = 0; i < num_types; i++) {
- struct btrfs_space_info *tmp;
- if (!slot_count)
- break;
- info = NULL;
- list_for_each_entry(tmp, &fs_info->space_info, list) {
- if (tmp->flags == types[i]) {
- info = tmp;
- break;
- }
- }
- if (!info)
- continue;
- down_read(&info->groups_sem);
- for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
- if (!list_empty(&info->block_groups[c])) {
- get_block_group_info(&info->block_groups[c],
- &space);
- memcpy(dest, &space, sizeof(space));
- dest++;
- space_args.total_spaces++;
- slot_count--;
- }
- if (!slot_count)
- break;
- }
- up_read(&info->groups_sem);
- }
- /*
- * Add global block reserve
- */
- if (slot_count) {
- struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
- spin_lock(&block_rsv->lock);
- space.total_bytes = block_rsv->size;
- space.used_bytes = block_rsv->size - block_rsv->reserved;
- spin_unlock(&block_rsv->lock);
- space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV;
- memcpy(dest, &space, sizeof(space));
- space_args.total_spaces++;
- }
- user_dest = (struct btrfs_ioctl_space_info __user *)
- (arg + sizeof(struct btrfs_ioctl_space_args));
- if (copy_to_user(user_dest, dest_orig, alloc_size))
- ret = -EFAULT;
- kfree(dest_orig);
- out:
- if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
- ret = -EFAULT;
- return ret;
- }
- static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
- void __user *argp)
- {
- struct btrfs_trans_handle *trans;
- u64 transid;
- int ret;
- trans = btrfs_attach_transaction_barrier(root);
- if (IS_ERR(trans)) {
- if (PTR_ERR(trans) != -ENOENT)
- return PTR_ERR(trans);
- /* No running transaction, don't bother */
- transid = root->fs_info->last_trans_committed;
- goto out;
- }
- transid = trans->transid;
- ret = btrfs_commit_transaction_async(trans, 0);
- if (ret) {
- btrfs_end_transaction(trans);
- return ret;
- }
- out:
- if (argp)
- if (copy_to_user(argp, &transid, sizeof(transid)))
- return -EFAULT;
- return 0;
- }
- static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info,
- void __user *argp)
- {
- u64 transid;
- if (argp) {
- if (copy_from_user(&transid, argp, sizeof(transid)))
- return -EFAULT;
- } else {
- transid = 0; /* current trans */
- }
- return btrfs_wait_for_commit(fs_info, transid);
- }
- static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
- {
- struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb);
- struct btrfs_ioctl_scrub_args *sa;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa))
- return PTR_ERR(sa);
- if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
- ret = mnt_want_write_file(file);
- if (ret)
- goto out;
- }
- ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end,
- &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
- 0);
- /*
- * Copy scrub args to user space even if btrfs_scrub_dev() returned an
- * error. This is important as it allows user space to know how much
- * progress scrub has done. For example, if scrub is canceled we get
- * -ECANCELED from btrfs_scrub_dev() and return that error back to user
- * space. Later user space can inspect the progress from the structure
- * btrfs_ioctl_scrub_args and resume scrub from where it left off
- * previously (btrfs-progs does this).
- * If we fail to copy the btrfs_ioctl_scrub_args structure to user space
- * then return -EFAULT to signal the structure was not copied or it may
- * be corrupt and unreliable due to a partial copy.
- */
- if (copy_to_user(arg, sa, sizeof(*sa)))
- ret = -EFAULT;
- if (!(sa->flags & BTRFS_SCRUB_READONLY))
- mnt_drop_write_file(file);
- out:
- kfree(sa);
- return ret;
- }
- static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info)
- {
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- return btrfs_scrub_cancel(fs_info);
- }
- static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_scrub_args *sa;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa))
- return PTR_ERR(sa);
- ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress);
- if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
- ret = -EFAULT;
- kfree(sa);
- return ret;
- }
- static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_get_dev_stats *sa;
- int ret;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa))
- return PTR_ERR(sa);
- if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) {
- kfree(sa);
- return -EPERM;
- }
- ret = btrfs_get_dev_stats(fs_info, sa);
- if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
- ret = -EFAULT;
- kfree(sa);
- return ret;
- }
- static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_dev_replace_args *p;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- p = memdup_user(arg, sizeof(*p));
- if (IS_ERR(p))
- return PTR_ERR(p);
- switch (p->cmd) {
- case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
- if (sb_rdonly(fs_info->sb)) {
- ret = -EROFS;
- goto out;
- }
- if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {
- ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- } else {
- ret = btrfs_dev_replace_by_ioctl(fs_info, p);
- btrfs_exclop_finish(fs_info);
- }
- break;
- case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
- btrfs_dev_replace_status(fs_info, p);
- ret = 0;
- break;
- case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
- p->result = btrfs_dev_replace_cancel(fs_info);
- ret = 0;
- break;
- default:
- ret = -EINVAL;
- break;
- }
- if ((ret == 0 || ret == -ECANCELED) && copy_to_user(arg, p, sizeof(*p)))
- ret = -EFAULT;
- out:
- kfree(p);
- return ret;
- }
- static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
- {
- int ret = 0;
- int i;
- u64 rel_ptr;
- int size;
- struct btrfs_ioctl_ino_path_args *ipa = NULL;
- struct inode_fs_paths *ipath = NULL;
- struct btrfs_path *path;
- if (!capable(CAP_DAC_READ_SEARCH))
- return -EPERM;
- path = btrfs_alloc_path();
- if (!path) {
- ret = -ENOMEM;
- goto out;
- }
- ipa = memdup_user(arg, sizeof(*ipa));
- if (IS_ERR(ipa)) {
- ret = PTR_ERR(ipa);
- ipa = NULL;
- goto out;
- }
- size = min_t(u32, ipa->size, 4096);
- ipath = init_ipath(size, root, path);
- if (IS_ERR(ipath)) {
- ret = PTR_ERR(ipath);
- ipath = NULL;
- goto out;
- }
- ret = paths_from_inode(ipa->inum, ipath);
- if (ret < 0)
- goto out;
- for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
- rel_ptr = ipath->fspath->val[i] -
- (u64)(unsigned long)ipath->fspath->val;
- ipath->fspath->val[i] = rel_ptr;
- }
- ret = copy_to_user((void __user *)(unsigned long)ipa->fspath,
- ipath->fspath, size);
- if (ret) {
- ret = -EFAULT;
- goto out;
- }
- out:
- btrfs_free_path(path);
- free_ipath(ipath);
- kfree(ipa);
- return ret;
- }
- static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx)
- {
- struct btrfs_data_container *inodes = ctx;
- const size_t c = 3 * sizeof(u64);
- if (inodes->bytes_left >= c) {
- inodes->bytes_left -= c;
- inodes->val[inodes->elem_cnt] = inum;
- inodes->val[inodes->elem_cnt + 1] = offset;
- inodes->val[inodes->elem_cnt + 2] = root;
- inodes->elem_cnt += 3;
- } else {
- inodes->bytes_missing += c - inodes->bytes_left;
- inodes->bytes_left = 0;
- inodes->elem_missed += 3;
- }
- return 0;
- }
- static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info,
- void __user *arg, int version)
- {
- int ret = 0;
- int size;
- struct btrfs_ioctl_logical_ino_args *loi;
- struct btrfs_data_container *inodes = NULL;
- struct btrfs_path *path = NULL;
- bool ignore_offset;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- loi = memdup_user(arg, sizeof(*loi));
- if (IS_ERR(loi))
- return PTR_ERR(loi);
- if (version == 1) {
- ignore_offset = false;
- size = min_t(u32, loi->size, SZ_64K);
- } else {
- /* All reserved bits must be 0 for now */
- if (memchr_inv(loi->reserved, 0, sizeof(loi->reserved))) {
- ret = -EINVAL;
- goto out_loi;
- }
- /* Only accept flags we have defined so far */
- if (loi->flags & ~(BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET)) {
- ret = -EINVAL;
- goto out_loi;
- }
- ignore_offset = loi->flags & BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET;
- size = min_t(u32, loi->size, SZ_16M);
- }
- path = btrfs_alloc_path();
- if (!path) {
- ret = -ENOMEM;
- goto out;
- }
- inodes = init_data_container(size);
- if (IS_ERR(inodes)) {
- ret = PTR_ERR(inodes);
- inodes = NULL;
- goto out;
- }
- ret = iterate_inodes_from_logical(loi->logical, fs_info, path,
- build_ino_list, inodes, ignore_offset);
- if (ret == -EINVAL)
- ret = -ENOENT;
- if (ret < 0)
- goto out;
- ret = copy_to_user((void __user *)(unsigned long)loi->inodes, inodes,
- size);
- if (ret)
- ret = -EFAULT;
- out:
- btrfs_free_path(path);
- kvfree(inodes);
- out_loi:
- kfree(loi);
- return ret;
- }
- void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
- struct btrfs_ioctl_balance_args *bargs)
- {
- struct btrfs_balance_control *bctl = fs_info->balance_ctl;
- bargs->flags = bctl->flags;
- if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags))
- bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
- if (atomic_read(&fs_info->balance_pause_req))
- bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
- if (atomic_read(&fs_info->balance_cancel_req))
- bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
- memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
- memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
- memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
- spin_lock(&fs_info->balance_lock);
- memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
- spin_unlock(&fs_info->balance_lock);
- }
- static long btrfs_ioctl_balance(struct file *file, void __user *arg)
- {
- struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
- struct btrfs_fs_info *fs_info = root->fs_info;
- struct btrfs_ioctl_balance_args *bargs;
- struct btrfs_balance_control *bctl;
- bool need_unlock; /* for mut. excl. ops lock */
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- again:
- if (btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {
- mutex_lock(&fs_info->balance_mutex);
- need_unlock = true;
- goto locked;
- }
- /*
- * mut. excl. ops lock is locked. Three possibilities:
- * (1) some other op is running
- * (2) balance is running
- * (3) balance is paused -- special case (think resume)
- */
- mutex_lock(&fs_info->balance_mutex);
- if (fs_info->balance_ctl) {
- /* this is either (2) or (3) */
- if (!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {
- mutex_unlock(&fs_info->balance_mutex);
- /*
- * Lock released to allow other waiters to continue,
- * we'll reexamine the status again.
- */
- mutex_lock(&fs_info->balance_mutex);
- if (fs_info->balance_ctl &&
- !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {
- /* this is (3) */
- need_unlock = false;
- goto locked;
- }
- mutex_unlock(&fs_info->balance_mutex);
- goto again;
- } else {
- /* this is (2) */
- mutex_unlock(&fs_info->balance_mutex);
- ret = -EINPROGRESS;
- goto out;
- }
- } else {
- /* this is (1) */
- mutex_unlock(&fs_info->balance_mutex);
- ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
- goto out;
- }
- locked:
- if (arg) {
- bargs = memdup_user(arg, sizeof(*bargs));
- if (IS_ERR(bargs)) {
- ret = PTR_ERR(bargs);
- goto out_unlock;
- }
- if (bargs->flags & BTRFS_BALANCE_RESUME) {
- if (!fs_info->balance_ctl) {
- ret = -ENOTCONN;
- goto out_bargs;
- }
- bctl = fs_info->balance_ctl;
- spin_lock(&fs_info->balance_lock);
- bctl->flags |= BTRFS_BALANCE_RESUME;
- spin_unlock(&fs_info->balance_lock);
- goto do_balance;
- }
- } else {
- bargs = NULL;
- }
- if (fs_info->balance_ctl) {
- ret = -EINPROGRESS;
- goto out_bargs;
- }
- bctl = kzalloc(sizeof(*bctl), GFP_KERNEL);
- if (!bctl) {
- ret = -ENOMEM;
- goto out_bargs;
- }
- if (arg) {
- memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
- memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
- memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));
- bctl->flags = bargs->flags;
- } else {
- /* balance everything - no filters */
- bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
- }
- if (bctl->flags & ~(BTRFS_BALANCE_ARGS_MASK | BTRFS_BALANCE_TYPE_MASK)) {
- ret = -EINVAL;
- goto out_bctl;
- }
- do_balance:
- /*
- * Ownership of bctl and exclusive operation goes to btrfs_balance.
- * bctl is freed in reset_balance_state, or, if restriper was paused
- * all the way until unmount, in free_fs_info. The flag should be
- * cleared after reset_balance_state.
- */
- need_unlock = false;
- ret = btrfs_balance(fs_info, bctl, bargs);
- bctl = NULL;
- if ((ret == 0 || ret == -ECANCELED) && arg) {
- if (copy_to_user(arg, bargs, sizeof(*bargs)))
- ret = -EFAULT;
- }
- out_bctl:
- kfree(bctl);
- out_bargs:
- kfree(bargs);
- out_unlock:
- mutex_unlock(&fs_info->balance_mutex);
- if (need_unlock)
- btrfs_exclop_finish(fs_info);
- out:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd)
- {
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- switch (cmd) {
- case BTRFS_BALANCE_CTL_PAUSE:
- return btrfs_pause_balance(fs_info);
- case BTRFS_BALANCE_CTL_CANCEL:
- return btrfs_cancel_balance(fs_info);
- }
- return -EINVAL;
- }
- static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_balance_args *bargs;
- int ret = 0;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- mutex_lock(&fs_info->balance_mutex);
- if (!fs_info->balance_ctl) {
- ret = -ENOTCONN;
- goto out;
- }
- bargs = kzalloc(sizeof(*bargs), GFP_KERNEL);
- if (!bargs) {
- ret = -ENOMEM;
- goto out;
- }
- btrfs_update_ioctl_balance_args(fs_info, bargs);
- if (copy_to_user(arg, bargs, sizeof(*bargs)))
- ret = -EFAULT;
- kfree(bargs);
- out:
- mutex_unlock(&fs_info->balance_mutex);
- return ret;
- }
- static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_ioctl_quota_ctl_args *sa;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa)) {
- ret = PTR_ERR(sa);
- goto drop_write;
- }
- down_write(&fs_info->subvol_sem);
- switch (sa->cmd) {
- case BTRFS_QUOTA_CTL_ENABLE:
- ret = btrfs_quota_enable(fs_info);
- break;
- case BTRFS_QUOTA_CTL_DISABLE:
- ret = btrfs_quota_disable(fs_info);
- break;
- default:
- ret = -EINVAL;
- break;
- }
- kfree(sa);
- up_write(&fs_info->subvol_sem);
- drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_ioctl_qgroup_assign_args *sa;
- struct btrfs_trans_handle *trans;
- int ret;
- int err;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa)) {
- ret = PTR_ERR(sa);
- goto drop_write;
- }
- trans = btrfs_join_transaction(root);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out;
- }
- if (sa->assign) {
- ret = btrfs_add_qgroup_relation(trans, sa->src, sa->dst);
- } else {
- ret = btrfs_del_qgroup_relation(trans, sa->src, sa->dst);
- }
- /* update qgroup status and info */
- err = btrfs_run_qgroups(trans);
- if (err < 0)
- btrfs_handle_fs_error(fs_info, err,
- "failed to update qgroup status and info");
- err = btrfs_end_transaction(trans);
- if (err && !ret)
- ret = err;
- out:
- kfree(sa);
- drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_ioctl_qgroup_create_args *sa;
- struct btrfs_trans_handle *trans;
- int ret;
- int err;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa)) {
- ret = PTR_ERR(sa);
- goto drop_write;
- }
- if (!sa->qgroupid) {
- ret = -EINVAL;
- goto out;
- }
- trans = btrfs_join_transaction(root);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out;
- }
- if (sa->create) {
- ret = btrfs_create_qgroup(trans, sa->qgroupid);
- } else {
- ret = btrfs_remove_qgroup(trans, sa->qgroupid);
- }
- err = btrfs_end_transaction(trans);
- if (err && !ret)
- ret = err;
- out:
- kfree(sa);
- drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_ioctl_qgroup_limit_args *sa;
- struct btrfs_trans_handle *trans;
- int ret;
- int err;
- u64 qgroupid;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa)) {
- ret = PTR_ERR(sa);
- goto drop_write;
- }
- trans = btrfs_join_transaction(root);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out;
- }
- qgroupid = sa->qgroupid;
- if (!qgroupid) {
- /* take the current subvol as qgroup */
- qgroupid = root->root_key.objectid;
- }
- ret = btrfs_limit_qgroup(trans, qgroupid, &sa->lim);
- err = btrfs_end_transaction(trans);
- if (err && !ret)
- ret = err;
- out:
- kfree(sa);
- drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_ioctl_quota_rescan_args *qsa;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- qsa = memdup_user(arg, sizeof(*qsa));
- if (IS_ERR(qsa)) {
- ret = PTR_ERR(qsa);
- goto drop_write;
- }
- if (qsa->flags) {
- ret = -EINVAL;
- goto out;
- }
- ret = btrfs_qgroup_rescan(fs_info);
- out:
- kfree(qsa);
- drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static long btrfs_ioctl_quota_rescan_status(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_ioctl_quota_rescan_args *qsa;
- int ret = 0;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- qsa = kzalloc(sizeof(*qsa), GFP_KERNEL);
- if (!qsa)
- return -ENOMEM;
- if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
- qsa->flags = 1;
- qsa->progress = fs_info->qgroup_rescan_progress.objectid;
- }
- if (copy_to_user(arg, qsa, sizeof(*qsa)))
- ret = -EFAULT;
- kfree(qsa);
- return ret;
- }
- static long btrfs_ioctl_quota_rescan_wait(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- return btrfs_qgroup_wait_for_completion(fs_info, true);
- }
- static long _btrfs_ioctl_set_received_subvol(struct file *file,
- struct btrfs_ioctl_received_subvol_args *sa)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_root_item *root_item = &root->root_item;
- struct btrfs_trans_handle *trans;
- struct timespec64 ct = current_time(inode);
- int ret = 0;
- int received_uuid_changed;
- if (!inode_owner_or_capable(inode))
- return -EPERM;
- ret = mnt_want_write_file(file);
- if (ret < 0)
- return ret;
- down_write(&fs_info->subvol_sem);
- if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
- ret = -EINVAL;
- goto out;
- }
- if (btrfs_root_readonly(root)) {
- ret = -EROFS;
- goto out;
- }
- /*
- * 1 - root item
- * 2 - uuid items (received uuid + subvol uuid)
- */
- trans = btrfs_start_transaction(root, 3);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- trans = NULL;
- goto out;
- }
- sa->rtransid = trans->transid;
- sa->rtime.sec = ct.tv_sec;
- sa->rtime.nsec = ct.tv_nsec;
- received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid,
- BTRFS_UUID_SIZE);
- if (received_uuid_changed &&
- !btrfs_is_empty_uuid(root_item->received_uuid)) {
- ret = btrfs_uuid_tree_remove(trans, root_item->received_uuid,
- BTRFS_UUID_KEY_RECEIVED_SUBVOL,
- root->root_key.objectid);
- if (ret && ret != -ENOENT) {
- btrfs_abort_transaction(trans, ret);
- btrfs_end_transaction(trans);
- goto out;
- }
- }
- memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
- btrfs_set_root_stransid(root_item, sa->stransid);
- btrfs_set_root_rtransid(root_item, sa->rtransid);
- btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec);
- btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec);
- btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec);
- btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec);
- ret = btrfs_update_root(trans, fs_info->tree_root,
- &root->root_key, &root->root_item);
- if (ret < 0) {
- btrfs_end_transaction(trans);
- goto out;
- }
- if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
- ret = btrfs_uuid_tree_add(trans, sa->uuid,
- BTRFS_UUID_KEY_RECEIVED_SUBVOL,
- root->root_key.objectid);
- if (ret < 0 && ret != -EEXIST) {
- btrfs_abort_transaction(trans, ret);
- btrfs_end_transaction(trans);
- goto out;
- }
- }
- ret = btrfs_commit_transaction(trans);
- out:
- up_write(&fs_info->subvol_sem);
- mnt_drop_write_file(file);
- return ret;
- }
- #ifdef CONFIG_64BIT
- static long btrfs_ioctl_set_received_subvol_32(struct file *file,
- void __user *arg)
- {
- struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL;
- struct btrfs_ioctl_received_subvol_args *args64 = NULL;
- int ret = 0;
- args32 = memdup_user(arg, sizeof(*args32));
- if (IS_ERR(args32))
- return PTR_ERR(args32);
- args64 = kmalloc(sizeof(*args64), GFP_KERNEL);
- if (!args64) {
- ret = -ENOMEM;
- goto out;
- }
- memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE);
- args64->stransid = args32->stransid;
- args64->rtransid = args32->rtransid;
- args64->stime.sec = args32->stime.sec;
- args64->stime.nsec = args32->stime.nsec;
- args64->rtime.sec = args32->rtime.sec;
- args64->rtime.nsec = args32->rtime.nsec;
- args64->flags = args32->flags;
- ret = _btrfs_ioctl_set_received_subvol(file, args64);
- if (ret)
- goto out;
- memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE);
- args32->stransid = args64->stransid;
- args32->rtransid = args64->rtransid;
- args32->stime.sec = args64->stime.sec;
- args32->stime.nsec = args64->stime.nsec;
- args32->rtime.sec = args64->rtime.sec;
- args32->rtime.nsec = args64->rtime.nsec;
- args32->flags = args64->flags;
- ret = copy_to_user(arg, args32, sizeof(*args32));
- if (ret)
- ret = -EFAULT;
- out:
- kfree(args32);
- kfree(args64);
- return ret;
- }
- #endif
- static long btrfs_ioctl_set_received_subvol(struct file *file,
- void __user *arg)
- {
- struct btrfs_ioctl_received_subvol_args *sa = NULL;
- int ret = 0;
- sa = memdup_user(arg, sizeof(*sa));
- if (IS_ERR(sa))
- return PTR_ERR(sa);
- ret = _btrfs_ioctl_set_received_subvol(file, sa);
- if (ret)
- goto out;
- ret = copy_to_user(arg, sa, sizeof(*sa));
- if (ret)
- ret = -EFAULT;
- out:
- kfree(sa);
- return ret;
- }
- static int btrfs_ioctl_get_fslabel(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- size_t len;
- int ret;
- char label[BTRFS_LABEL_SIZE];
- spin_lock(&fs_info->super_lock);
- memcpy(label, fs_info->super_copy->label, BTRFS_LABEL_SIZE);
- spin_unlock(&fs_info->super_lock);
- len = strnlen(label, BTRFS_LABEL_SIZE);
- if (len == BTRFS_LABEL_SIZE) {
- btrfs_warn(fs_info,
- "label is too long, return the first %zu bytes",
- --len);
- }
- ret = copy_to_user(arg, label, len);
- return ret ? -EFAULT : 0;
- }
- static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_super_block *super_block = fs_info->super_copy;
- struct btrfs_trans_handle *trans;
- char label[BTRFS_LABEL_SIZE];
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- if (copy_from_user(label, arg, sizeof(label)))
- return -EFAULT;
- if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
- btrfs_err(fs_info,
- "unable to set label with more than %d bytes",
- BTRFS_LABEL_SIZE - 1);
- return -EINVAL;
- }
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_unlock;
- }
- spin_lock(&fs_info->super_lock);
- strcpy(super_block->label, label);
- spin_unlock(&fs_info->super_lock);
- ret = btrfs_commit_transaction(trans);
- out_unlock:
- mnt_drop_write_file(file);
- return ret;
- }
- #define INIT_FEATURE_FLAGS(suffix) \
- { .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \
- .compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \
- .incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix }
- int btrfs_ioctl_get_supported_features(void __user *arg)
- {
- static const struct btrfs_ioctl_feature_flags features[3] = {
- INIT_FEATURE_FLAGS(SUPP),
- INIT_FEATURE_FLAGS(SAFE_SET),
- INIT_FEATURE_FLAGS(SAFE_CLEAR)
- };
- if (copy_to_user(arg, &features, sizeof(features)))
- return -EFAULT;
- return 0;
- }
- static int btrfs_ioctl_get_features(struct btrfs_fs_info *fs_info,
- void __user *arg)
- {
- struct btrfs_super_block *super_block = fs_info->super_copy;
- struct btrfs_ioctl_feature_flags features;
- features.compat_flags = btrfs_super_compat_flags(super_block);
- features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block);
- features.incompat_flags = btrfs_super_incompat_flags(super_block);
- if (copy_to_user(arg, &features, sizeof(features)))
- return -EFAULT;
- return 0;
- }
- static int check_feature_bits(struct btrfs_fs_info *fs_info,
- enum btrfs_feature_set set,
- u64 change_mask, u64 flags, u64 supported_flags,
- u64 safe_set, u64 safe_clear)
- {
- const char *type = btrfs_feature_set_name(set);
- char *names;
- u64 disallowed, unsupported;
- u64 set_mask = flags & change_mask;
- u64 clear_mask = ~flags & change_mask;
- unsupported = set_mask & ~supported_flags;
- if (unsupported) {
- names = btrfs_printable_features(set, unsupported);
- if (names) {
- btrfs_warn(fs_info,
- "this kernel does not support the %s feature bit%s",
- names, strchr(names, ',') ? "s" : "");
- kfree(names);
- } else
- btrfs_warn(fs_info,
- "this kernel does not support %s bits 0x%llx",
- type, unsupported);
- return -EOPNOTSUPP;
- }
- disallowed = set_mask & ~safe_set;
- if (disallowed) {
- names = btrfs_printable_features(set, disallowed);
- if (names) {
- btrfs_warn(fs_info,
- "can't set the %s feature bit%s while mounted",
- names, strchr(names, ',') ? "s" : "");
- kfree(names);
- } else
- btrfs_warn(fs_info,
- "can't set %s bits 0x%llx while mounted",
- type, disallowed);
- return -EPERM;
- }
- disallowed = clear_mask & ~safe_clear;
- if (disallowed) {
- names = btrfs_printable_features(set, disallowed);
- if (names) {
- btrfs_warn(fs_info,
- "can't clear the %s feature bit%s while mounted",
- names, strchr(names, ',') ? "s" : "");
- kfree(names);
- } else
- btrfs_warn(fs_info,
- "can't clear %s bits 0x%llx while mounted",
- type, disallowed);
- return -EPERM;
- }
- return 0;
- }
- #define check_feature(fs_info, change_mask, flags, mask_base) \
- check_feature_bits(fs_info, FEAT_##mask_base, change_mask, flags, \
- BTRFS_FEATURE_ ## mask_base ## _SUPP, \
- BTRFS_FEATURE_ ## mask_base ## _SAFE_SET, \
- BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR)
- static int btrfs_ioctl_set_features(struct file *file, void __user *arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct btrfs_super_block *super_block = fs_info->super_copy;
- struct btrfs_ioctl_feature_flags flags[2];
- struct btrfs_trans_handle *trans;
- u64 newflags;
- int ret;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- if (copy_from_user(flags, arg, sizeof(flags)))
- return -EFAULT;
- /* Nothing to do */
- if (!flags[0].compat_flags && !flags[0].compat_ro_flags &&
- !flags[0].incompat_flags)
- return 0;
- ret = check_feature(fs_info, flags[0].compat_flags,
- flags[1].compat_flags, COMPAT);
- if (ret)
- return ret;
- ret = check_feature(fs_info, flags[0].compat_ro_flags,
- flags[1].compat_ro_flags, COMPAT_RO);
- if (ret)
- return ret;
- ret = check_feature(fs_info, flags[0].incompat_flags,
- flags[1].incompat_flags, INCOMPAT);
- if (ret)
- return ret;
- ret = mnt_want_write_file(file);
- if (ret)
- return ret;
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- ret = PTR_ERR(trans);
- goto out_drop_write;
- }
- spin_lock(&fs_info->super_lock);
- newflags = btrfs_super_compat_flags(super_block);
- newflags |= flags[0].compat_flags & flags[1].compat_flags;
- newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags);
- btrfs_set_super_compat_flags(super_block, newflags);
- newflags = btrfs_super_compat_ro_flags(super_block);
- newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags;
- newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags);
- btrfs_set_super_compat_ro_flags(super_block, newflags);
- newflags = btrfs_super_incompat_flags(super_block);
- newflags |= flags[0].incompat_flags & flags[1].incompat_flags;
- newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags);
- btrfs_set_super_incompat_flags(super_block, newflags);
- spin_unlock(&fs_info->super_lock);
- ret = btrfs_commit_transaction(trans);
- out_drop_write:
- mnt_drop_write_file(file);
- return ret;
- }
- static int _btrfs_ioctl_send(struct file *file, void __user *argp, bool compat)
- {
- struct btrfs_ioctl_send_args *arg;
- int ret;
- if (compat) {
- #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
- struct btrfs_ioctl_send_args_32 args32;
- ret = copy_from_user(&args32, argp, sizeof(args32));
- if (ret)
- return -EFAULT;
- arg = kzalloc(sizeof(*arg), GFP_KERNEL);
- if (!arg)
- return -ENOMEM;
- arg->send_fd = args32.send_fd;
- arg->clone_sources_count = args32.clone_sources_count;
- arg->clone_sources = compat_ptr(args32.clone_sources);
- arg->parent_root = args32.parent_root;
- arg->flags = args32.flags;
- memcpy(arg->reserved, args32.reserved,
- sizeof(args32.reserved));
- #else
- return -ENOTTY;
- #endif
- } else {
- arg = memdup_user(argp, sizeof(*arg));
- if (IS_ERR(arg))
- return PTR_ERR(arg);
- }
- ret = btrfs_ioctl_send(file, arg);
- kfree(arg);
- return ret;
- }
- long btrfs_ioctl(struct file *file, unsigned int
- cmd, unsigned long arg)
- {
- struct inode *inode = file_inode(file);
- struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
- struct btrfs_root *root = BTRFS_I(inode)->root;
- void __user *argp = (void __user *)arg;
- switch (cmd) {
- case FS_IOC_GETFLAGS:
- return btrfs_ioctl_getflags(file, argp);
- case FS_IOC_SETFLAGS:
- return btrfs_ioctl_setflags(file, argp);
- case FS_IOC_GETVERSION:
- return btrfs_ioctl_getversion(file, argp);
- case FS_IOC_GETFSLABEL:
- return btrfs_ioctl_get_fslabel(fs_info, argp);
- case FS_IOC_SETFSLABEL:
- return btrfs_ioctl_set_fslabel(file, argp);
- case FITRIM:
- return btrfs_ioctl_fitrim(fs_info, argp);
- case BTRFS_IOC_SNAP_CREATE:
- return btrfs_ioctl_snap_create(file, argp, 0);
- case BTRFS_IOC_SNAP_CREATE_V2:
- return btrfs_ioctl_snap_create_v2(file, argp, 0);
- case BTRFS_IOC_SUBVOL_CREATE:
- return btrfs_ioctl_snap_create(file, argp, 1);
- case BTRFS_IOC_SUBVOL_CREATE_V2:
- return btrfs_ioctl_snap_create_v2(file, argp, 1);
- case BTRFS_IOC_SNAP_DESTROY:
- return btrfs_ioctl_snap_destroy(file, argp, false);
- case BTRFS_IOC_SNAP_DESTROY_V2:
- return btrfs_ioctl_snap_destroy(file, argp, true);
- case BTRFS_IOC_SUBVOL_GETFLAGS:
- return btrfs_ioctl_subvol_getflags(file, argp);
- case BTRFS_IOC_SUBVOL_SETFLAGS:
- return btrfs_ioctl_subvol_setflags(file, argp);
- case BTRFS_IOC_DEFAULT_SUBVOL:
- return btrfs_ioctl_default_subvol(file, argp);
- case BTRFS_IOC_DEFRAG:
- return btrfs_ioctl_defrag(file, NULL);
- case BTRFS_IOC_DEFRAG_RANGE:
- return btrfs_ioctl_defrag(file, argp);
- case BTRFS_IOC_RESIZE:
- return btrfs_ioctl_resize(file, argp);
- case BTRFS_IOC_ADD_DEV:
- return btrfs_ioctl_add_dev(fs_info, argp);
- case BTRFS_IOC_RM_DEV:
- return btrfs_ioctl_rm_dev(file, argp);
- case BTRFS_IOC_RM_DEV_V2:
- return btrfs_ioctl_rm_dev_v2(file, argp);
- case BTRFS_IOC_FS_INFO:
- return btrfs_ioctl_fs_info(fs_info, argp);
- case BTRFS_IOC_DEV_INFO:
- return btrfs_ioctl_dev_info(fs_info, argp);
- case BTRFS_IOC_BALANCE:
- return btrfs_ioctl_balance(file, NULL);
- case BTRFS_IOC_TREE_SEARCH:
- return btrfs_ioctl_tree_search(file, argp);
- case BTRFS_IOC_TREE_SEARCH_V2:
- return btrfs_ioctl_tree_search_v2(file, argp);
- case BTRFS_IOC_INO_LOOKUP:
- return btrfs_ioctl_ino_lookup(file, argp);
- case BTRFS_IOC_INO_PATHS:
- return btrfs_ioctl_ino_to_path(root, argp);
- case BTRFS_IOC_LOGICAL_INO:
- return btrfs_ioctl_logical_to_ino(fs_info, argp, 1);
- case BTRFS_IOC_LOGICAL_INO_V2:
- return btrfs_ioctl_logical_to_ino(fs_info, argp, 2);
- case BTRFS_IOC_SPACE_INFO:
- return btrfs_ioctl_space_info(fs_info, argp);
- case BTRFS_IOC_SYNC: {
- int ret;
- ret = btrfs_start_delalloc_roots(fs_info, U64_MAX, false);
- if (ret)
- return ret;
- ret = btrfs_sync_fs(inode->i_sb, 1);
- /*
- * The transaction thread may want to do more work,
- * namely it pokes the cleaner kthread that will start
- * processing uncleaned subvols.
- */
- wake_up_process(fs_info->transaction_kthread);
- return ret;
- }
- case BTRFS_IOC_START_SYNC:
- return btrfs_ioctl_start_sync(root, argp);
- case BTRFS_IOC_WAIT_SYNC:
- return btrfs_ioctl_wait_sync(fs_info, argp);
- case BTRFS_IOC_SCRUB:
- return btrfs_ioctl_scrub(file, argp);
- case BTRFS_IOC_SCRUB_CANCEL:
- return btrfs_ioctl_scrub_cancel(fs_info);
- case BTRFS_IOC_SCRUB_PROGRESS:
- return btrfs_ioctl_scrub_progress(fs_info, argp);
- case BTRFS_IOC_BALANCE_V2:
- return btrfs_ioctl_balance(file, argp);
- case BTRFS_IOC_BALANCE_CTL:
- return btrfs_ioctl_balance_ctl(fs_info, arg);
- case BTRFS_IOC_BALANCE_PROGRESS:
- return btrfs_ioctl_balance_progress(fs_info, argp);
- case BTRFS_IOC_SET_RECEIVED_SUBVOL:
- return btrfs_ioctl_set_received_subvol(file, argp);
- #ifdef CONFIG_64BIT
- case BTRFS_IOC_SET_RECEIVED_SUBVOL_32:
- return btrfs_ioctl_set_received_subvol_32(file, argp);
- #endif
- case BTRFS_IOC_SEND:
- return _btrfs_ioctl_send(file, argp, false);
- #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
- case BTRFS_IOC_SEND_32:
- return _btrfs_ioctl_send(file, argp, true);
- #endif
- case BTRFS_IOC_GET_DEV_STATS:
- return btrfs_ioctl_get_dev_stats(fs_info, argp);
- case BTRFS_IOC_QUOTA_CTL:
- return btrfs_ioctl_quota_ctl(file, argp);
- case BTRFS_IOC_QGROUP_ASSIGN:
- return btrfs_ioctl_qgroup_assign(file, argp);
- case BTRFS_IOC_QGROUP_CREATE:
- return btrfs_ioctl_qgroup_create(file, argp);
- case BTRFS_IOC_QGROUP_LIMIT:
- return btrfs_ioctl_qgroup_limit(file, argp);
- case BTRFS_IOC_QUOTA_RESCAN:
- return btrfs_ioctl_quota_rescan(file, argp);
- case BTRFS_IOC_QUOTA_RESCAN_STATUS:
- return btrfs_ioctl_quota_rescan_status(fs_info, argp);
- case BTRFS_IOC_QUOTA_RESCAN_WAIT:
- return btrfs_ioctl_quota_rescan_wait(fs_info, argp);
- case BTRFS_IOC_DEV_REPLACE:
- return btrfs_ioctl_dev_replace(fs_info, argp);
- case BTRFS_IOC_GET_SUPPORTED_FEATURES:
- return btrfs_ioctl_get_supported_features(argp);
- case BTRFS_IOC_GET_FEATURES:
- return btrfs_ioctl_get_features(fs_info, argp);
- case BTRFS_IOC_SET_FEATURES:
- return btrfs_ioctl_set_features(file, argp);
- case FS_IOC_FSGETXATTR:
- return btrfs_ioctl_fsgetxattr(file, argp);
- case FS_IOC_FSSETXATTR:
- return btrfs_ioctl_fssetxattr(file, argp);
- case BTRFS_IOC_GET_SUBVOL_INFO:
- return btrfs_ioctl_get_subvol_info(file, argp);
- case BTRFS_IOC_GET_SUBVOL_ROOTREF:
- return btrfs_ioctl_get_subvol_rootref(file, argp);
- case BTRFS_IOC_INO_LOOKUP_USER:
- return btrfs_ioctl_ino_lookup_user(file, argp);
- }
- return -ENOTTY;
- }
- #ifdef CONFIG_COMPAT
- long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
- {
- /*
- * These all access 32-bit values anyway so no further
- * handling is necessary.
- */
- switch (cmd) {
- case FS_IOC32_GETFLAGS:
- cmd = FS_IOC_GETFLAGS;
- break;
- case FS_IOC32_SETFLAGS:
- cmd = FS_IOC_SETFLAGS;
- break;
- case FS_IOC32_GETVERSION:
- cmd = FS_IOC_GETVERSION;
- break;
- }
- return btrfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
- }
- #endif
|